@schmock/query 2.3.0 → 2.3.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Khalic Lab
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,41 @@
+# @schmock/query
+
+Pagination, sorting, and filtering for Schmock list endpoints, driven by query parameters.
+
+Part of [Schmock](https://github.com/khalic-lab/schmock) — mock APIs from OpenAPI specs or hand-crafted routes.
+
+## Install
+
+```bash
+bun add -d @schmock/query
+```
+
+## Usage
+
+```typescript
+import { schmock } from "@schmock/core";
+import { queryPlugin } from "@schmock/query";
+
+const mock = schmock();
+
+mock("GET /users", users).pipe(
+  queryPlugin({
+    pagination: { defaultLimit: 10, maxLimit: 100 },
+    sorting: { allowed: ["name"] },
+  }),
+);
+
+// Through an adapter: GET /users?page=2&limit=10&sort=name
+const response = await mock.handle("GET", "/users", {
+  query: { page: "2", limit: "10", sort: "name" },
+});
+```
+
+## Documentation
+
+- [API reference](https://github.com/khalic-lab/schmock/blob/main/docs/api.md)
+- [Plugin development](https://github.com/khalic-lab/schmock/blob/main/docs/plugins.md)
+
+## License
+
+MIT © Khalic Lab

package/dist/index.d.ts

@@ -1,4 +1,5 @@
-interface PaginationOptions {
+import type * as Schmock from "@schmock/core";
+export interface PaginationOptions {
     /** Default items per page (default: 10) */
     defaultLimit?: number;
     /** Maximum items per page (default: 100) */
@@ -8,7 +9,7 @@ interface PaginationOptions {
     /** Query parameter name for limit (default: "limit") */
     limitParam?: string;
 }
-interface SortingOptions {
+export interface SortingOptions {
     /** Fields allowed for sorting */
     allowed: string[];
     /** Default sort field */
@@ -20,17 +21,25 @@ interface SortingOptions {
     /** Query parameter name for sort order (default: "order") */
     orderParam?: string;
 }
-interface FilteringOptions {
+export interface FilteringOptions {
     /** Fields allowed for filtering */
     allowed: string[];
     /** Query parameter prefix for filters (default: "filter") */
     filterPrefix?: string;
 }
-interface QueryPluginOptions {
+export interface QueryPluginOptions {
     pagination?: PaginationOptions;
     sorting?: SortingOptions;
     filtering?: FilteringOptions;
 }
-export declare function queryPlugin(options: QueryPluginOptions): Schmock.Plugin;
-export {};
+export declare function queryPlugin(options?: QueryPluginOptions): Schmock.Plugin;
+export interface PaginatedResult {
+    data: unknown[];
+    pagination: {
+        page: number;
+        limit: number;
+        total: number;
+        totalPages: number;
+    };
+}
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAKA,UAAU,iBAAiB;IACzB,2CAA2C;IAC3C,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,4CAA4C;IAC5C,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,6DAA6D;IAC7D,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,wDAAwD;IACxD,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,UAAU,cAAc;IACtB,iCAAiC;IACjC,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,yBAAyB;IACzB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,0CAA0C;IAC1C,YAAY,CAAC,EAAE,KAAK,GAAG,MAAM,CAAC;IAC9B,4DAA4D;IAC5D,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,6DAA6D;IAC7D,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,UAAU,gBAAgB;IACxB,mCAAmC;IACnC,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,6DAA6D;IAC7D,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,UAAU,kBAAkB;IAC1B,UAAU,CAAC,EAAE,iBAAiB,CAAC;IAC/B,OAAO,CAAC,EAAE,cAAc,CAAC;IACzB,SAAS,CAAC,EAAE,gBAAgB,CAAC;CAC9B;AA2CD,wBAAgB,WAAW,CAAC,OAAO,EAAE,kBAAkB,GAAG,OAAO,CAAC,MAAM,CAoCvE"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,OAAO,MAAM,eAAe,CAAC;AAI9C,MAAM,WAAW,iBAAiB;IAChC,2CAA2C;IAC3C,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,4CAA4C;IAC5C,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,6DAA6D;IAC7D,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,wDAAwD;IACxD,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,cAAc;IAC7B,iCAAiC;IACjC,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,yBAAyB;IACzB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,0CAA0C;IAC1C,YAAY,CAAC,EAAE,KAAK,GAAG,MAAM,CAAC;IAC9B,4DAA4D;IAC5D,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,6DAA6D;IAC7D,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,gBAAgB;IAC/B,mCAAmC;IACnC,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,6DAA6D;IAC7D,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,kBAAkB;IACjC,UAAU,CAAC,EAAE,iBAAiB,CAAC;IAC/B,OAAO,CAAC,EAAE,cAAc,CAAC;IACzB,SAAS,CAAC,EAAE,gBAAgB,CAAC;CAC9B;AA6LD,wBAAgB,WAAW,CAAC,OAAO,GAAE,kBAAuB,GAAG,OAAO,CAAC,MAAM,CA2C5E;AA4JD,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,OAAO,EAAE,CAAC;IAChB,UAAU,EAAE;QACV,IAAI,EAAE,MAAM,CAAC;QACb,KAAK,EAAE,MAAM,CAAC;QACd,KAAK,EAAE,MAAM,CAAC;QACd,UAAU,EAAE,MAAM,CAAC;KACpB,CAAC;CACH"}

package/dist/index.js

@@ -1 +1 @@
-import{isStatusTuple as N}from"@schmock/core";var I="2.3.0";function H(c){return typeof c==="object"&&c!==null}function W(c){return H(c)&&Object.values(c).every((h)=>typeof h==="string")}function Q(c){return H(c)&&!Array.isArray(c)&&typeof c.status==="number"&&"body"in c&&(c.headers===void 0||W(c.headers))}function X(c){if(N(c))return c[1];if(Q(c))return c.body;return c}function J(c,h){if(N(c))return c.length===3?[c[0],h,c[2]]:[c[0],h];if(Q(c))return{...c,body:h};return h}function T(c){return{name:"query",version:I,process(h,j){let M=X(j);if(!Array.isArray(M))return{context:h,response:j};let w=[...M],k=h.query||{};if(c.filtering)w=Y(w,k,c.filtering);if(c.sorting)w=Z(w,k,c.sorting);if(c.pagination){let C=_(w,k,c.pagination);return{context:h,response:J(j,C)}}return{context:h,response:J(j,w)}}}}function Y(c,h,j){let M=j.filterPrefix??"filter",w=c;for(let k of j.allowed){let C=`${M}[${k}]`,E=`${M}.${k}`,f=h[C]??h[E]??h[k];if(f!==void 0)w=w.filter((z)=>{if(!H(z))return!1;let D=z[k];if(D===void 0)return!1;return String(D)===f})}return w}function Z(c,h,j){let M=j.sortParam??"sort",w=j.orderParam??"order",k=h[M]??j.default,E=(h[w]??j.defaultOrder??"asc")==="desc"?"desc":"asc";if(!k)return c;if(!j.allowed.includes(k))return c;return c.sort((f,z)=>{if(!H(f)||!H(z))return 0;let D=f[k],A=z[k];if(D===A)return 0;if(D===void 0)return 1;if(A===void 0)return-1;let G;if(typeof D==="number"&&typeof A==="number")G=D-A;else G=String(D).localeCompare(String(A));return E==="desc"?-G:G})}function _(c,h,j){let M=j.pageParam??"page",w=j.limitParam??"limit",k=j.defaultLimit??10,C=j.maxLimit??100,E=Math.max(1,Number.parseInt(h[M]||"1",10)||1),f=Math.min(C,Math.max(1,Number.parseInt(h[w]||String(k),10)||k)),z=c.length,D=Math.ceil(z/f),A=(E-1)*f;return{data:c.slice(A,A+f),pagination:{page:E,limit:f,total:z,totalPages:D}}}export{T as queryPlugin};
+import{isStatusTuple as L,SchmockError as F}from"@schmock/core";var _="2.3.1";var c=new Set(["__proto__","constructor","prototype"]);function T(h){return typeof h==="object"&&h!==null}function W(h,j){try{return Object.hasOwn(h,j)?h[j]:void 0}catch{return}}function O(h){try{return typeof h==="string"?JSON.stringify(h):String(h)}catch{return"<unprintable>"}}function Z(h,j,M){return new F(`queryPlugin: ${h} (received ${O(M)})`,"QUERY_CONFIG_INVALID",{option:j,received:M})}function I(h,j){if(h===void 0)return;if(typeof h!=="number"||!Number.isSafeInteger(h)||h<1)throw Z(`${j} must be a positive integer`,j,h)}function Y(h,j){if(h===void 0)return;if(typeof h!=="string"||h.length===0)throw Z(`${j} must be a non-empty string`,j,h)}function K(h,j){if(!Array.isArray(h))throw Z(`${j} must be an array of field names`,j,h);for(let M of h){if(typeof M!=="string"||M.length===0)throw Z(`${j} must contain only non-empty field names`,j,M);if(c.has(M))throw Z(`${j} must not contain the reserved field name`,j,M)}}function V(h){let{pagination:j,sorting:M,filtering:z}=h;if(j)I(j.defaultLimit,"pagination.defaultLimit"),I(j.maxLimit,"pagination.maxLimit"),Y(j.pageParam,"pagination.pageParam"),Y(j.limitParam,"pagination.limitParam");if(M)K(M.allowed,"sorting.allowed"),Y(M.sortParam,"sorting.sortParam"),Y(M.orderParam,"sorting.orderParam");if(z)K(z.allowed,"filtering.allowed"),Y(z.filterPrefix,"filtering.filterPrefix")}function q(h){let{pagination:j,sorting:M,filtering:z}=h,D,H,Q;if(j){let{defaultLimit:J,maxLimit:G,pageParam:U,limitParam:X}=j;D={defaultLimit:J,maxLimit:G,pageParam:U,limitParam:X}}if(M){let{allowed:J,default:G,defaultOrder:U,sortParam:X,orderParam:$}=M;H={allowed:Array.isArray(J)?[...J]:J,default:G,defaultOrder:U,sortParam:X,orderParam:$}}if(z){let{allowed:J,filterPrefix:G}=z;Q={allowed:Array.isArray(J)?[...J]:J,filterPrefix:G}}return{pagination:D,sorting:H,filtering:Q}}function P(h){return T(h)&&!Array.isArray(h)&&Object.values(h).every((j)=>typeof j==="string")}function N(h){return T(h)&&!Array.isArray(h)&&typeof h.status==="number"&&"body"in h&&(h.headers===void 0||P(h.headers))}function E(h){if(L(h))return h[1];if(N(h))return h.body;return h}function k(h,j){if(L(h))return h.length===3?[h[0],j,h[2]]:[h[0],j];if(N(h))return h.headers===void 0?{status:h.status,body:j}:{status:h.status,body:j,headers:h.headers};return j}function u(h={}){let j=q(h);return V(j),{name:"query",version:_,process(M,z){let D=E(z);if(!Array.isArray(D))return{context:M,response:z};let H=[...D],Q=M.query||{};if(j.filtering)H=R(H,Q,j.filtering);if(j.sorting)H=b(H,Q,j.sorting);if(j.pagination){let J=d(H,Q,j.pagination);return{context:M,response:k(z,J)}}return{context:M,response:k(z,H)}}}}function R(h,j,M){let z=M.filterPrefix??"filter",D=h;for(let H of M.allowed){let Q=W(j,`${z}[${H}]`)??W(j,`${z}.${H}`);if(Q!==void 0)D=D.filter((J)=>{if(!T(J))return!1;let G=W(J,H);if(G===void 0)return!1;try{return String(G)===Q}catch{return!1}})}return D}function w(h,j){if(h<j)return-1;return h>j?1:0}function S(h){if(h===void 0)return{kind:"missing"};if(h===null)return{kind:"null"};if(typeof h==="number")return Number.isFinite(h)?{kind:"number",value:h}:{kind:"non-finite-number",value:h};if(typeof h==="string")return{kind:"string",value:h};if(typeof h==="boolean")return{kind:"boolean",value:h};if(typeof h==="bigint")return{kind:"bigint",value:h};return{kind:"unsupported"}}function A(h){switch(h.kind){case"number":return 0;case"non-finite-number":return 1;case"string":return 2;case"boolean":return 3;case"bigint":return 4;case"null":return 5;case"unsupported":return 6;case"missing":return 7}}function C(h){if(h===Number.NEGATIVE_INFINITY)return 0;if(h===Number.POSITIVE_INFINITY)return 1;return 2}function f(h,j,M){if(h.kind==="missing"||j.kind==="missing"){if(h.kind===j.kind)return 0;return h.kind==="missing"?1:-1}if(h.kind==="unsupported"||j.kind==="unsupported"){if(h.kind===j.kind)return 0;return h.kind==="unsupported"?1:-1}let z=A(h)-A(j),D=z;if(z===0){if(h.kind==="number"&&j.kind==="number")D=h.value<j.value?-1:h.value>j.value?1:0;else if(h.kind==="non-finite-number"&&j.kind==="non-finite-number")D=C(h.value)-C(j.value);else if(h.kind==="string"&&j.kind==="string")D=w(h.value,j.value);else if(h.kind==="boolean"&&j.kind==="boolean")D=Number(h.value)-Number(j.value);else if(h.kind==="bigint"&&j.kind==="bigint")D=h.value<j.value?-1:h.value>j.value?1:0}return M==="desc"?-D:D}function b(h,j,M){let z=M.sortParam??"sort",D=M.orderParam??"order",H=W(j,z)??M.default,J=(W(j,D)??M.defaultOrder??"asc")==="desc"?"desc":"asc";if(!H)return h;if(!M.allowed.includes(H))return h;return h.map((G)=>({item:G,key:S(T(G)?W(G,H):void 0)})).sort((G,U)=>f(G.key,U.key,J)).map(({item:G})=>G)}function B(h,j){if(typeof h!=="string"||!/^[0-9]+$/.test(h))return j;let M=Number(h);return Number.isSafeInteger(M)&&M>=1?M:j}function d(h,j,M){let z=M.pageParam??"page",D=M.limitParam??"limit",H=M.defaultLimit??10,Q=M.maxLimit??100,J=B(W(j,z),1),G=Math.min(Q,B(W(j,D),H)),U=h.length,X=Math.ceil(U/G),$=(J-1)*G;return{data:h.slice($,$+G),pagination:{page:J,limit:G,total:U,totalPages:X}}}export{u as queryPlugin};

package/package.json

@@ -1,13 +1,21 @@
 {
   "name": "@schmock/query",
   "description": "Pagination, filtering, and sorting plugin for Schmock",
-  "version": "2.3.0",
+  "version": "2.3.1",
   "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/khalic-lab/schmock.git",
+    "directory": "packages/query"
+  },
+  "homepage": "https://github.com/khalic-lab/schmock/tree/main/packages/query#readme",
+  "bugs": {
+    "url": "https://github.com/khalic-lab/schmock/issues"
+  },
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "files": [
-    "dist",
-    "src"
+    "dist"
   ],
   "exports": {
     ".": {
@@ -18,7 +26,8 @@
     "./package.json": "./package.json"
   },
   "scripts": {
-    "build": "bun build:lib && bun build:types",
+    "clean": "rm -rf dist && rm -f tsconfig.tsbuildinfo",
+    "build": "bun run clean && bun run build:lib && bun run build:types",
     "build:lib": "bun build --minify --target node --format esm --outdir=dist src/index.ts --external @schmock/core",
     "build:types": "tsc -p tsconfig.json",
     "test": "vitest run",
@@ -30,7 +39,7 @@
   },
   "license": "MIT",
   "peerDependencies": {
-    "@schmock/core": "^2.3.0"
+    "@schmock/core": "^2.3.1"
   },
   "devDependencies": {
     "@amiceli/vitest-cucumber": "^7.0.0",

package/src/index.test.ts

@@ -1,591 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { version as packageVersion } from "../package.json";
-import { queryPlugin } from "./index";
-
-describe("queryPlugin", () => {
-  it("creates a plugin with correct name", () => {
-    const plugin = queryPlugin({ pagination: {} });
-    expect(plugin.name).toBe("query");
-    expect(plugin.version).toBe(packageVersion);
-  });
-
-  it("passes through non-array responses", async () => {
-    const plugin = queryPlugin({ pagination: {} });
-    const result = await plugin.process(
-      {
-        path: "/test",
-        route: {},
-        method: "GET",
-        params: {},
-        query: {},
-        headers: {},
-        state: new Map(),
-      },
-      { message: "not an array" },
-    );
-
-    expect(result.response).toEqual({ message: "not an array" });
-  });
-
-  it("paginates array responses", async () => {
-    const plugin = queryPlugin({
-      pagination: { defaultLimit: 2, maxLimit: 10 },
-    });
-
-    const items = [{ id: 1 }, { id: 2 }, { id: 3 }, { id: 4 }, { id: 5 }];
-    const result = await plugin.process(
-      {
-        path: "/test",
-        route: {},
-        method: "GET",
-        params: {},
-        query: { page: "2", limit: "2" },
-        headers: {},
-        state: new Map(),
-      },
-      items,
-    );
-
-    expect(result.response).toEqual({
-      data: [{ id: 3 }, { id: 4 }],
-      pagination: { page: 2, limit: 2, total: 5, totalPages: 3 },
-    });
-  });
-
-  it("paginates the array body of a two-element status tuple", async () => {
-    const plugin = queryPlugin({
-      pagination: { defaultLimit: 2, maxLimit: 10 },
-    });
-    const items = [{ id: 1 }, { id: 2 }, { id: 3 }, { id: 4 }, { id: 5 }];
-    const context: Schmock.PluginContext = {
-      path: "/test",
-      route: {},
-      method: "GET",
-      params: {},
-      query: { page: "2", limit: "2" },
-      headers: {},
-      state: new Map(),
-    };
-
-    const result = await plugin.process(context, [206, items] satisfies [
-      number,
-      unknown,
-    ]);
-
-    expect(result.response).toEqual([
-      206,
-      {
-        data: [{ id: 3 }, { id: 4 }],
-        pagination: { page: 2, limit: 2, total: 5, totalPages: 3 },
-      },
-    ]);
-  });
-
-  it("paginates a status tuple body without changing its headers", async () => {
-    const plugin = queryPlugin({
-      pagination: { defaultLimit: 2, maxLimit: 10 },
-    });
-    const items = [{ id: 1 }, { id: 2 }, { id: 3 }, { id: 4 }, { id: 5 }];
-    const headers = {
-      "content-type": "application/json",
-      "x-response-source": "tuple",
-    };
-    const context: Schmock.PluginContext = {
-      path: "/test",
-      route: {},
-      method: "GET",
-      params: {},
-      query: { page: "2", limit: "2" },
-      headers: {},
-      state: new Map(),
-    };
-
-    const result = await plugin.process(context, [
-      206,
-      items,
-      headers,
-    ] satisfies [number, unknown, Record<string, string>]);
-
-    expect(result.response).toEqual([
-      206,
-      {
-        data: [{ id: 3 }, { id: 4 }],
-        pagination: { page: 2, limit: 2, total: 5, totalPages: 3 },
-      },
-      headers,
-    ]);
-  });
-
-  it("paginates a structured response body without changing metadata", async () => {
-    const plugin = queryPlugin({
-      pagination: { defaultLimit: 2, maxLimit: 10 },
-    });
-    const items = [{ id: 1 }, { id: 2 }, { id: 3 }, { id: 4 }, { id: 5 }];
-    const response = {
-      status: 206,
-      body: items,
-      headers: { "x-response-source": "structured" },
-    };
-    const context: Schmock.PluginContext = {
-      path: "/test",
-      route: {},
-      method: "GET",
-      params: {},
-      query: { page: "2", limit: "2" },
-      headers: {},
-      state: new Map(),
-    };
-
-    const result = await plugin.process(context, response);
-
-    expect(result.response).toEqual({
-      status: 206,
-      body: {
-        data: [{ id: 3 }, { id: 4 }],
-        pagination: { page: 2, limit: 2, total: 5, totalPages: 3 },
-      },
-      headers: { "x-response-source": "structured" },
-    });
-  });
-
-  it("passes response containers through when their semantic body is not an array", async () => {
-    const plugin = queryPlugin({ pagination: { defaultLimit: 2 } });
-    const context: Schmock.PluginContext = {
-      path: "/test",
-      route: {},
-      method: "GET",
-      params: {},
-      query: { page: "2", limit: "2" },
-      headers: {},
-      state: new Map(),
-    };
-    const responses: unknown[] = [
-      [
-        202,
-        { message: "accepted" },
-        { "x-response-source": "tuple" },
-      ] satisfies [number, unknown, Record<string, string>],
-      {
-        status: 202,
-        body: { message: "accepted" },
-        headers: { "x-response-source": "structured" },
-      },
-    ];
-
-    for (const response of responses) {
-      const result = await plugin.process(context, response);
-      expect(result.response).toBe(response);
-    }
-  });
-
-  it("sorts array responses", async () => {
-    const plugin = queryPlugin({
-      sorting: { allowed: ["name"], default: "name" },
-    });
-
-    const items = [
-      { id: 3, name: "Charlie" },
-      { id: 1, name: "Alice" },
-      { id: 2, name: "Bob" },
-    ];
-
-    const result = await plugin.process(
-      {
-        path: "/test",
-        route: {},
-        method: "GET",
-        params: {},
-        query: { sort: "name", order: "asc" },
-        headers: {},
-        state: new Map(),
-      },
-      items,
-    );
-
-    expect(result.response.map((i: any) => i.name)).toEqual([
-      "Alice",
-      "Bob",
-      "Charlie",
-    ]);
-  });
-
-  it("filters array responses", async () => {
-    const plugin = queryPlugin({
-      filtering: { allowed: ["role"] },
-    });
-
-    const items = [
-      { id: 1, name: "Alice", role: "admin" },
-      { id: 2, name: "Bob", role: "user" },
-      { id: 3, name: "Charlie", role: "admin" },
-    ];
-
-    const result = await plugin.process(
-      {
-        path: "/test",
-        route: {},
-        method: "GET",
-        params: {},
-        query: { "filter[role]": "admin" },
-        headers: {},
-        state: new Map(),
-      },
-      items,
-    );
-
-    expect(result.response).toHaveLength(2);
-    expect(result.response.every((i: any) => i.role === "admin")).toBe(true);
-  });
-
-  it("respects maxLimit", async () => {
-    const plugin = queryPlugin({
-      pagination: { defaultLimit: 5, maxLimit: 3 },
-    });
-
-    const items = Array.from({ length: 10 }, (_, i) => ({ id: i }));
-    const result = await plugin.process(
-      {
-        path: "/test",
-        route: {},
-        method: "GET",
-        params: {},
-        query: { limit: "100" },
-        headers: {},
-        state: new Map(),
-      },
-      items,
-    );
-
-    expect(result.response.data).toHaveLength(3);
-  });
-
-  describe("filtering edge cases", () => {
-    it("returns empty result when input array is empty", async () => {
-      const plugin = queryPlugin({
-        filtering: { allowed: ["role"] },
-      });
-
-      const result = await plugin.process(
-        {
-          path: "/test",
-          route: {},
-          method: "GET",
-          params: {},
-          query: { "filter[role]": "admin" },
-          headers: {},
-          state: new Map(),
-        },
-        [],
-      );
-
-      expect(result.response).toEqual([]);
-    });
-
-    it("excludes items that lack the filter field", async () => {
-      const plugin = queryPlugin({
-        filtering: { allowed: ["role"] },
-      });
-
-      const items = [
-        { id: 1, role: "admin" },
-        { id: 2, name: "no-role" },
-        { id: 3, role: "admin" },
-      ];
-
-      const result = await plugin.process(
-        {
-          path: "/test",
-          route: {},
-          method: "GET",
-          params: {},
-          query: { "filter[role]": "admin" },
-          headers: {},
-          state: new Map(),
-        },
-        items,
-      );
-
-      expect(result.response).toHaveLength(2);
-      expect(result.response.every((i: any) => i.role === "admin")).toBe(true);
-    });
-
-    it("handles filter value with special regex characters as literal string", async () => {
-      const plugin = queryPlugin({
-        filtering: { allowed: ["domain"] },
-      });
-
-      const items = [
-        { id: 1, domain: "foo.bar" },
-        { id: 2, domain: "fooXbar" },
-        { id: 3, domain: "foo.bar" },
-      ];
-
-      const result = await plugin.process(
-        {
-          path: "/test",
-          route: {},
-          method: "GET",
-          params: {},
-          query: { "filter[domain]": "foo.bar" },
-          headers: {},
-          state: new Map(),
-        },
-        items,
-      );
-
-      expect(result.response).toHaveLength(2);
-      expect(result.response.every((i: any) => i.domain === "foo.bar")).toBe(
-        true,
-      );
-    });
-  });
-
-  describe("sorting edge cases", () => {
-    it("sorts with mixed numeric and string values in the sort field", async () => {
-      const plugin = queryPlugin({
-        sorting: { allowed: ["score"], default: "score" },
-      });
-
-      const items = [
-        { id: 1, score: 10 },
-        { id: 2, score: "5" },
-        { id: 3, score: 2 },
-      ];
-
-      const result = await plugin.process(
-        {
-          path: "/test",
-          route: {},
-          method: "GET",
-          params: {},
-          query: { sort: "score", order: "asc" },
-          headers: {},
-          state: new Map(),
-        },
-        items,
-      );
-
-      // Mixed types fall back to localeCompare via String() coercion
-      expect(result.response).toHaveLength(3);
-    });
-
-    it("pushes items with undefined sort field values to the end", async () => {
-      const plugin = queryPlugin({
-        sorting: { allowed: ["name"], default: "name" },
-      });
-
-      const items = [
-        { id: 1 },
-        { id: 2, name: "Alice" },
-        { id: 3, name: "Bob" },
-      ];
-
-      const result = await plugin.process(
-        {
-          path: "/test",
-          route: {},
-          method: "GET",
-          params: {},
-          query: { sort: "name", order: "asc" },
-          headers: {},
-          state: new Map(),
-        },
-        items,
-      );
-
-      expect(result.response[0].name).toBe("Alice");
-      expect(result.response[1].name).toBe("Bob");
-      expect(result.response[2].name).toBeUndefined();
-    });
-
-    it("maintains relative order for items with equal sort values", async () => {
-      const plugin = queryPlugin({
-        sorting: { allowed: ["priority"], default: "priority" },
-      });
-
-      const items = [
-        { id: 1, priority: 1, label: "first" },
-        { id: 2, priority: 1, label: "second" },
-        { id: 3, priority: 1, label: "third" },
-      ];
-
-      const result = await plugin.process(
-        {
-          path: "/test",
-          route: {},
-          method: "GET",
-          params: {},
-          query: { sort: "priority", order: "asc" },
-          headers: {},
-          state: new Map(),
-        },
-        items,
-      );
-
-      // Sort stability: equal values preserve insertion order
-      expect(result.response.map((i: any) => i.label)).toEqual([
-        "first",
-        "second",
-        "third",
-      ]);
-    });
-  });
-
-  describe("pagination edge cases", () => {
-    const makePaginationPlugin = (defaultLimit = 10, maxLimit = 100) =>
-      queryPlugin({
-        pagination: { defaultLimit, maxLimit },
-      });
-
-    const items = Array.from({ length: 5 }, (_, i) => ({ id: i + 1 }));
-
-    const makeContext = (query: Record<string, string>) => ({
-      path: "/test",
-      route: {},
-      method: "GET" as const,
-      params: {},
-      query,
-      headers: {},
-      state: new Map(),
-    });
-
-    it("clamps page=0 to page 1", async () => {
-      const plugin = makePaginationPlugin(2);
-      const result = await plugin.process(makeContext({ page: "0" }), items);
-
-      expect(result.response.pagination.page).toBe(1);
-      expect(result.response.data).toEqual([{ id: 1 }, { id: 2 }]);
-    });
-
-    it("clamps page=-1 to page 1", async () => {
-      const plugin = makePaginationPlugin(2);
-      const result = await plugin.process(makeContext({ page: "-1" }), items);
-
-      expect(result.response.pagination.page).toBe(1);
-      expect(result.response.data).toEqual([{ id: 1 }, { id: 2 }]);
-    });
-
-    it("clamps limit=0 to defaultLimit (0 is falsy, falls back to default)", async () => {
-      const plugin = makePaginationPlugin(10, 100);
-      const result = await plugin.process(makeContext({ limit: "0" }), items);
-
-      // parseInt("0") is 0, which is falsy → falls back to defaultLimit (10)
-      expect(result.response.pagination.limit).toBe(10);
-      expect(result.response.data).toHaveLength(5);
-    });
-
-    it("clamps limit exceeding maxLimit to maxLimit", async () => {
-      const plugin = makePaginationPlugin(10, 3);
-      const result = await plugin.process(makeContext({ limit: "999" }), items);
-
-      expect(result.response.pagination.limit).toBe(3);
-      expect(result.response.data).toHaveLength(3);
-    });
-
-    it("defaults gracefully when page is non-numeric", async () => {
-      const plugin = makePaginationPlugin(2);
-      const result = await plugin.process(makeContext({ page: "abc" }), items);
-
-      expect(result.response.pagination.page).toBe(1);
-      expect(result.response.data).toEqual([{ id: 1 }, { id: 2 }]);
-    });
-
-    it("defaults gracefully when limit is non-numeric", async () => {
-      const plugin = makePaginationPlugin(2);
-      const result = await plugin.process(makeContext({ limit: "abc" }), items);
-
-      expect(result.response.pagination.limit).toBe(2);
-      expect(result.response.data).toEqual([{ id: 1 }, { id: 2 }]);
-    });
-
-    it("returns empty data with correct total for a very large page number", async () => {
-      const plugin = makePaginationPlugin(2);
-      const result = await plugin.process(makeContext({ page: "9999" }), items);
-
-      expect(result.response.data).toEqual([]);
-      expect(result.response.pagination.total).toBe(5);
-      expect(result.response.pagination.totalPages).toBe(3);
-    });
-
-    it("returns data=[], total=0, totalPages=0 for empty array input", async () => {
-      const plugin = makePaginationPlugin(10);
-      const result = await plugin.process(makeContext({}), []);
-
-      expect(result.response.data).toEqual([]);
-      expect(result.response.pagination.total).toBe(0);
-      expect(result.response.pagination.totalPages).toBe(0);
-    });
-  });
-
-  describe("process method edge cases", () => {
-    it("passes through null response unchanged", async () => {
-      const plugin = queryPlugin({
-        pagination: { defaultLimit: 10 },
-        filtering: { allowed: ["role"] },
-        sorting: { allowed: ["name"] },
-      });
-
-      const result = await plugin.process(
-        {
-          path: "/test",
-          route: {},
-          method: "GET",
-          params: {},
-          query: {},
-          headers: {},
-          state: new Map(),
-        },
-        null,
-      );
-
-      expect(result.response).toBeNull();
-    });
-
-    it("passes through object (non-array) response unchanged", async () => {
-      const plugin = queryPlugin({
-        pagination: { defaultLimit: 10 },
-        filtering: { allowed: ["role"] },
-        sorting: { allowed: ["name"] },
-      });
-
-      const obj = { message: "hello", count: 42 };
-      const result = await plugin.process(
-        {
-          path: "/test",
-          route: {},
-          method: "GET",
-          params: {},
-          query: {},
-          headers: {},
-          state: new Map(),
-        },
-        obj,
-      );
-
-      expect(result.response).toEqual(obj);
-    });
-
-    it("passes through undefined response unchanged", async () => {
-      const plugin = queryPlugin({
-        pagination: { defaultLimit: 10 },
-        filtering: { allowed: ["role"] },
-        sorting: { allowed: ["name"] },
-      });
-
-      const result = await plugin.process(
-        {
-          path: "/test",
-          route: {},
-          method: "GET",
-          params: {},
-          query: {},
-          headers: {},
-          state: new Map(),
-        },
-        undefined,
-      );
-
-      expect(result.response).toBeUndefined();
-    });
-  });
-});

package/src/index.ts

@@ -1,232 +0,0 @@
-/// <reference path="../../core/schmock.d.ts" />
-
-import { isStatusTuple } from "@schmock/core";
-import { version as packageVersion } from "../package.json";
-
-interface PaginationOptions {
-  /** Default items per page (default: 10) */
-  defaultLimit?: number;
-  /** Maximum items per page (default: 100) */
-  maxLimit?: number;
-  /** Query parameter name for page number (default: "page") */
-  pageParam?: string;
-  /** Query parameter name for limit (default: "limit") */
-  limitParam?: string;
-}
-
-interface SortingOptions {
-  /** Fields allowed for sorting */
-  allowed: string[];
-  /** Default sort field */
-  default?: string;
-  /** Default sort order (default: "asc") */
-  defaultOrder?: "asc" | "desc";
-  /** Query parameter name for sort field (default: "sort") */
-  sortParam?: string;
-  /** Query parameter name for sort order (default: "order") */
-  orderParam?: string;
-}
-
-interface FilteringOptions {
-  /** Fields allowed for filtering */
-  allowed: string[];
-  /** Query parameter prefix for filters (default: "filter") */
-  filterPrefix?: string;
-}
-
-interface QueryPluginOptions {
-  pagination?: PaginationOptions;
-  sorting?: SortingOptions;
-  filtering?: FilteringOptions;
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null;
-}
-
-function isStringRecord(value: unknown): value is Record<string, string> {
-  return (
-    isRecord(value) &&
-    Object.values(value).every((entry) => typeof entry === "string")
-  );
-}
-
-function isStructuredResponse(value: unknown): value is {
-  status: number;
-  body: unknown;
-  headers?: Record<string, string>;
-} {
-  return (
-    isRecord(value) &&
-    !Array.isArray(value) &&
-    typeof value.status === "number" &&
-    "body" in value &&
-    (value.headers === undefined || isStringRecord(value.headers))
-  );
-}
-
-function getResponseBody(response: unknown): unknown {
-  if (isStatusTuple(response)) return response[1];
-  if (isStructuredResponse(response)) return response.body;
-  return response;
-}
-
-function replaceResponseBody(response: unknown, body: unknown): unknown {
-  if (isStatusTuple(response)) {
-    return response.length === 3
-      ? [response[0], body, response[2]]
-      : [response[0], body];
-  }
-  if (isStructuredResponse(response)) return { ...response, body };
-  return body;
-}
-
-export function queryPlugin(options: QueryPluginOptions): Schmock.Plugin {
-  return {
-    name: "query",
-    version: packageVersion,
-
-    process(
-      context: Schmock.PluginContext,
-      response?: unknown,
-    ): Schmock.PluginResult {
-      const responseBody = getResponseBody(response);
-      if (!Array.isArray(responseBody)) {
-        return { context, response };
-      }
-
-      let items: unknown[] = [...responseBody];
-      const query = context.query || {};
-
-      // Apply filtering
-      if (options.filtering) {
-        items = applyFiltering(items, query, options.filtering);
-      }
-
-      // Apply sorting
-      if (options.sorting) {
-        items = applySorting(items, query, options.sorting);
-      }
-
-      // Apply pagination
-      if (options.pagination) {
-        const result = applyPagination(items, query, options.pagination);
-        return { context, response: replaceResponseBody(response, result) };
-      }
-
-      return { context, response: replaceResponseBody(response, items) };
-    },
-  };
-}
-
-function applyFiltering(
-  items: unknown[],
-  query: Record<string, string>,
-  options: FilteringOptions,
-): unknown[] {
-  const prefix = options.filterPrefix ?? "filter";
-  let result = items;
-
-  for (const field of options.allowed) {
-    // Support filter[field]=value format
-    const bracketKey = `${prefix}[${field}]`;
-    // Support filter.field=value format
-    const dotKey = `${prefix}.${field}`;
-    // Support plain field=value format as fallback
-    const value = query[bracketKey] ?? query[dotKey] ?? query[field];
-
-    if (value !== undefined) {
-      result = result.filter((item) => {
-        if (!isRecord(item)) return false;
-        const itemValue = item[field];
-        if (itemValue === undefined) return false;
-        // Intentional string coercion: query params are inherently strings
-        return String(itemValue) === value;
-      });
-    }
-  }
-
-  return result;
-}
-
-function applySorting(
-  items: unknown[],
-  query: Record<string, string>,
-  options: SortingOptions,
-): unknown[] {
-  const sortParam = options.sortParam ?? "sort";
-  const orderParam = options.orderParam ?? "order";
-  const sortField = query[sortParam] ?? options.default;
-  const rawOrder = query[orderParam] ?? options.defaultOrder ?? "asc";
-  const sortOrder = rawOrder === "desc" ? "desc" : "asc";
-
-  if (!sortField) return items;
-
-  // Only sort by allowed fields
-  if (!options.allowed.includes(sortField)) return items;
-
-  return items.sort((a, b) => {
-    if (!isRecord(a) || !isRecord(b)) return 0;
-    const aVal = a[sortField];
-    const bVal = b[sortField];
-
-    if (aVal === bVal) return 0;
-    if (aVal === undefined) return 1;
-    if (bVal === undefined) return -1;
-
-    let comparison: number;
-    if (typeof aVal === "number" && typeof bVal === "number") {
-      comparison = aVal - bVal;
-    } else {
-      comparison = String(aVal).localeCompare(String(bVal));
-    }
-
-    return sortOrder === "desc" ? -comparison : comparison;
-  });
-}
-
-interface PaginatedResult {
-  data: unknown[];
-  pagination: {
-    page: number;
-    limit: number;
-    total: number;
-    totalPages: number;
-  };
-}
-
-function applyPagination(
-  items: unknown[],
-  query: Record<string, string>,
-  options: PaginationOptions,
-): PaginatedResult {
-  const pageParam = options.pageParam ?? "page";
-  const limitParam = options.limitParam ?? "limit";
-  const defaultLimit = options.defaultLimit ?? 10;
-  const maxLimit = options.maxLimit ?? 100;
-
-  const page = Math.max(1, Number.parseInt(query[pageParam] || "1", 10) || 1);
-  const limit = Math.min(
-    maxLimit,
-    Math.max(
-      1,
-      Number.parseInt(query[limitParam] || String(defaultLimit), 10) ||
-        defaultLimit,
-    ),
-  );
-
-  const total = items.length;
-  const totalPages = Math.ceil(total / limit);
-  const start = (page - 1) * limit;
-  const data = items.slice(start, start + limit);
-
-  return {
-    data,
-    pagination: {
-      page,
-      limit,
-      total,
-      totalPages,
-    },
-  };
-}

package/src/steps/query-plugin.steps.ts

@@ -1,362 +0,0 @@
-import { describeFeature, loadFeature } from "@amiceli/vitest-cucumber";
-import { schmock } from "@schmock/core";
-import { expect } from "vitest";
-import { queryPlugin } from "../index";
-
-const feature = await loadFeature("../../features/query-plugin.feature");
-
-function isUnknownArray(value: unknown): value is unknown[] {
-  return Array.isArray(value);
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-function requireRecord(
-  value: unknown,
-  description: string,
-): Record<string, unknown> {
-  if (!isRecord(value)) {
-    throw new Error(`Expected ${description} to be an object`);
-  }
-  return value;
-}
-
-function requireRecordArray(
-  value: unknown,
-  description: string,
-): Record<string, unknown>[] {
-  if (!isUnknownArray(value)) {
-    throw new Error(`Expected ${description} to be an array`);
-  }
-  return value.map((item) => requireRecord(item, `${description} item`));
-}
-
-function requirePaginatedBody(response: Schmock.Response) {
-  const body = requireRecord(response.body, "paginated response body");
-  return {
-    data: requireRecordArray(body.data, "paginated response data"),
-    pagination: requireRecord(body.pagination, "pagination metadata"),
-  };
-}
-
-describeFeature(feature, ({ Scenario, ScenarioOutline }) => {
-  let mock: Schmock.CallableMockInstance;
-  let response: Schmock.Response;
-
-  // Generate test data
-  const generateItems = (count: number) =>
-    Array.from({ length: count }, (_, i) => ({
-      id: i + 1,
-      name: `Item ${i + 1}`,
-    }));
-
-  const namedItems = [
-    { id: 1, name: "Charlie" },
-    { id: 2, name: "Alice" },
-    { id: 3, name: "Bob" },
-  ];
-
-  const categorizedItems = [
-    { id: 1, name: "Alice", role: "admin" },
-    { id: 2, name: "Bob", role: "user" },
-    { id: 3, name: "Charlie", role: "admin" },
-    { id: 4, name: "Dave", role: "user" },
-    { id: 5, name: "Eve", role: "moderator" },
-  ];
-
-  Scenario(
-    "Basic pagination with default settings",
-    ({ Given, When, Then, And }) => {
-      Given("I create a mock with 25 items and pagination plugin", () => {
-        mock = schmock();
-        mock("GET /items", generateItems(25)).pipe(
-          queryPlugin({
-            pagination: { defaultLimit: 10, maxLimit: 100 },
-          }),
-        );
-      });
-
-      When("I request page 1", async () => {
-        response = await mock.handle("GET", "/items", {
-          query: { page: "1" },
-        });
-      });
-
-      Then("I should receive {int} items", (_, count: number) => {
-        expect(requirePaginatedBody(response).data).toHaveLength(count);
-      });
-
-      And("the pagination total should be {int}", (_, total: number) => {
-        expect(requirePaginatedBody(response).pagination.total).toBe(total);
-      });
-
-      And(
-        "the pagination totalPages should be {int}",
-        (_, totalPages: number) => {
-          expect(requirePaginatedBody(response).pagination.totalPages).toBe(
-            totalPages,
-          );
-        },
-      );
-    },
-  );
-
-  Scenario("Pagination with custom limit", ({ Given, When, Then, And }) => {
-    Given("I create a mock with 25 items and pagination plugin", () => {
-      mock = schmock();
-      mock("GET /items", generateItems(25)).pipe(
-        queryPlugin({
-          pagination: { defaultLimit: 10, maxLimit: 100 },
-        }),
-      );
-    });
-
-    When("I request page 1 with limit 5", async () => {
-      response = await mock.handle("GET", "/items", {
-        query: { page: "1", limit: "5" },
-      });
-    });
-
-    Then("I should receive {int} items", (_, count: number) => {
-      expect(requirePaginatedBody(response).data).toHaveLength(count);
-    });
-
-    And(
-      "the pagination totalPages should be {int}",
-      (_, totalPages: number) => {
-        expect(requirePaginatedBody(response).pagination.totalPages).toBe(
-          totalPages,
-        );
-      },
-    );
-  });
-
-  Scenario("Sort items ascending by name", ({ Given, When, Then, And }) => {
-    Given("I create a mock with named items and sorting plugin", () => {
-      mock = schmock();
-      mock("GET /items", namedItems).pipe(
-        queryPlugin({
-          sorting: { allowed: ["name", "id"], default: "id" },
-        }),
-      );
-    });
-
-    When(
-      "I request with sort {string} order {string}",
-      async (_, sort: string, order: string) => {
-        response = await mock.handle("GET", "/items", {
-          query: { sort, order },
-        });
-      },
-    );
-
-    Then("the first item name should be {string}", (_, name: string) => {
-      const items = requireRecordArray(response.body, "sorted response body");
-      expect(items.at(0)?.name).toBe(name);
-    });
-
-    And("the last item name should be {string}", (_, name: string) => {
-      const items = requireRecordArray(response.body, "sorted response body");
-      expect(items.at(-1)?.name).toBe(name);
-    });
-  });
-
-  Scenario("Sort items descending by name", ({ Given, When, Then, And }) => {
-    Given("I create a mock with named items and sorting plugin", () => {
-      mock = schmock();
-      mock("GET /items", namedItems).pipe(
-        queryPlugin({
-          sorting: { allowed: ["name", "id"], default: "id" },
-        }),
-      );
-    });
-
-    When(
-      "I request with sort {string} order {string}",
-      async (_, sort: string, order: string) => {
-        response = await mock.handle("GET", "/items", {
-          query: { sort, order },
-        });
-      },
-    );
-
-    Then("the first item name should be {string}", (_, name: string) => {
-      const items = requireRecordArray(response.body, "sorted response body");
-      expect(items.at(0)?.name).toBe(name);
-    });
-
-    And("the last item name should be {string}", (_, name: string) => {
-      const items = requireRecordArray(response.body, "sorted response body");
-      expect(items.at(-1)?.name).toBe(name);
-    });
-  });
-
-  Scenario("Filter items by field value", ({ Given, When, Then, And }) => {
-    Given("I create a mock with categorized items and filtering plugin", () => {
-      mock = schmock();
-      mock("GET /items", categorizedItems).pipe(
-        queryPlugin({
-          filtering: { allowed: ["role"] },
-        }),
-      );
-    });
-
-    When("I request with filter role {string}", async (_, role: string) => {
-      response = await mock.handle("GET", "/items", {
-        query: { "filter[role]": role },
-      });
-    });
-
-    Then("I should receive {int} filtered items", (_, count: number) => {
-      expect(
-        requireRecordArray(response.body, "filtered response body"),
-      ).toHaveLength(count);
-    });
-
-    And("all items should have role {string}", (_, role: string) => {
-      const items = requireRecordArray(response.body, "filtered response body");
-      for (const item of items) {
-        expect(item.role).toBe(role);
-      }
-    });
-  });
-
-  Scenario(
-    "Combined pagination, sorting, and filtering",
-    ({ Given, When, Then, And }) => {
-      const users = [
-        { id: 1, name: "Dave", role: "admin" },
-        { id: 2, name: "Alice", role: "user" },
-        { id: 3, name: "Charlie", role: "admin" },
-        { id: 4, name: "Bob", role: "admin" },
-        { id: 5, name: "Eve", role: "user" },
-        { id: 6, name: "Frank", role: "admin" },
-        { id: 7, name: "Grace", role: "user" },
-        { id: 8, name: "Hank", role: "admin" },
-        { id: 9, name: "Ivy", role: "user" },
-        { id: 10, name: "Jack", role: "admin" },
-        { id: 11, name: "Karen", role: "user" },
-        { id: 12, name: "Leo", role: "admin" },
-        { id: 13, name: "Mona", role: "user" },
-        { id: 14, name: "Nate", role: "admin" },
-        { id: 15, name: "Olivia", role: "user" },
-        { id: 16, name: "Paul", role: "admin" },
-        { id: 17, name: "Quinn", role: "user" },
-        { id: 18, name: "Rose", role: "admin" },
-        { id: 19, name: "Sam", role: "user" },
-        { id: 20, name: "Tina", role: "admin" },
-      ];
-
-      Given("I create a mock with 20 users and full query plugin", () => {
-        mock = schmock();
-        mock("GET /users", users).pipe(
-          queryPlugin({
-            pagination: { defaultLimit: 10, maxLimit: 100 },
-            sorting: { allowed: ["name", "id"] },
-            filtering: { allowed: ["role"] },
-          }),
-        );
-      });
-
-      When(
-        "I request page 1 with limit 2 filter role {string} and sort {string}",
-        async (_, role: string, sort: string) => {
-          response = await mock.handle("GET", "/users", {
-            query: { page: "1", limit: "2", "filter[role]": role, sort },
-          });
-        },
-      );
-
-      Then("I should receive {int} items", (_, count: number) => {
-        expect(requirePaginatedBody(response).data).toHaveLength(count);
-      });
-
-      And("the items should be sorted by name ascending", () => {
-        const names = requirePaginatedBody(response).data.map((item) => {
-          if (typeof item.name !== "string") {
-            throw new Error(
-              "Expected each paginated item to have a string name",
-            );
-          }
-          return item.name;
-        });
-        const sorted = [...names].sort();
-        expect(names).toEqual(sorted);
-      });
-
-      And("all items should have role {string}", (_, role: string) => {
-        for (const item of requirePaginatedBody(response).data) {
-          expect(item.role).toBe(role);
-        }
-      });
-
-      And("the pagination total should reflect filtered count", () => {
-        // 11 admins in the dataset
-        expect(requirePaginatedBody(response).pagination.total).toBe(11);
-      });
-    },
-  );
-
-  ScenarioOutline(
-    "Paginate array response containers without losing metadata",
-    ({ Given, When, Then, And }, variables) => {
-      Given("I create a mock returning 5 items in a {string} response", () => {
-        mock = schmock();
-        const headers = { "x-query-source": variables.container };
-        if (variables.container === "tuple") {
-          mock(
-            "GET /items",
-            () =>
-              [206, generateItems(5), headers] satisfies [
-                number,
-                unknown,
-                Record<string, string>,
-              ],
-          );
-        } else if (variables.container === "structured") {
-          mock("GET /items", () => ({
-            status: 206,
-            body: generateItems(5),
-            headers,
-          }));
-        } else {
-          throw new Error(
-            `Unsupported query response container: ${variables.container}`,
-          );
-        }
-        mock.pipe(
-          queryPlugin({
-            pagination: { defaultLimit: 10, maxLimit: 100 },
-          }),
-        );
-      });
-
-      When("I request page 2 with limit 2", async () => {
-        response = await mock.handle("GET", "/items", {
-          query: { page: "2", limit: "2" },
-        });
-      });
-
-      Then("the response status should be 206", () => {
-        expect(response.status).toBe(206);
-      });
-
-      And(
-        "response header {string} should be {string}",
-        (_, header: string) => {
-          expect(response.headers[header]).toBe(variables.container);
-        },
-      );
-
-      And("I should receive 2 items", () => {
-        expect(requirePaginatedBody(response).data).toHaveLength(2);
-      });
-
-      And("the pagination total should be 5", () => {
-        expect(requirePaginatedBody(response).pagination.total).toBe(5);
-      });
-    },
-  );
-});