@schmock/query 2.2.3 → 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":"AAIA,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;AAED,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 @@
-var B="2.2.3";function N(c){return{name:"query",version:B,process(h,d){if(!Array.isArray(d))return{context:h,response:d};let j=[...d],k=h.query||{};if(c.filtering)j=E(j,k,c.filtering);if(c.sorting)j=G(j,k,c.sorting);if(c.pagination){let v=H(j,k,c.pagination);return{context:h,response:v}}return{context:h,response:j}}}}function E(c,h,d){let j=d.filterPrefix??"filter",k=c;for(let v of d.allowed){let g=`${j}[${v}]`,f=`${j}.${v}`,b=h[g]??h[f]??h[v];if(b!==void 0)k=k.filter((w)=>{if(typeof w!=="object"||w===null)return!1;let D=w[v];if(D===void 0)return!1;return String(D)===b})}return k}function G(c,h,d){let j=d.sortParam??"sort",k=d.orderParam??"order",v=h[j]??d.default,f=(h[k]??d.defaultOrder??"asc")==="desc"?"desc":"asc";if(!v)return c;if(!d.allowed.includes(v))return c;return c.sort((b,w)=>{if(typeof b!=="object"||b===null)return 0;if(typeof w!=="object"||w===null)return 0;let z=b,D=w,M=z[v],T=D[v];if(M===T)return 0;if(M===void 0)return 1;if(T===void 0)return-1;let A;if(typeof M==="number"&&typeof T==="number")A=M-T;else A=String(M).localeCompare(String(T));return f==="desc"?-A:A})}function H(c,h,d){let j=d.pageParam??"page",k=d.limitParam??"limit",v=d.defaultLimit??10,g=d.maxLimit??100,f=Math.max(1,Number.parseInt(h[j]||"1",10)||1),b=Math.min(g,Math.max(1,Number.parseInt(h[k]||String(v),10)||v)),w=c.length,z=Math.ceil(w/b),D=(f-1)*b;return{data:c.slice(D,D+b),pagination:{page:f,limit:b,total:w,totalPages:z}}}export{N 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.2.3",
+  "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,10 +26,11 @@
     "./package.json": "./package.json"
   },
   "scripts": {
-    "build": "bun build:lib && bun build:types",
-    "build:lib": "bun build --minify --target node --outdir=dist src/index.ts",
+    "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",
+    "test": "vitest run",
     "test:watch": "vitest --watch",
     "test:bdd": "vitest run --config vitest.config.bdd.ts",
     "lint": "biome check src/*.ts",
@@ -30,7 +39,7 @@
   },
   "license": "MIT",
   "peerDependencies": {
-    "@schmock/core": "^2.2.3"
+    "@schmock/core": "^2.3.1"
   },
   "devDependencies": {
     "@amiceli/vitest-cucumber": "^7.0.0",

package/src/index.test.ts

@@ -1,465 +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("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,194 +0,0 @@
-/// <reference path="../../core/schmock.d.ts" />
-
-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;
-}
-
-export function queryPlugin(options: QueryPluginOptions): Schmock.Plugin {
-  return {
-    name: "query",
-    version: packageVersion,
-
-    process(
-      context: Schmock.PluginContext,
-      response?: unknown,
-    ): Schmock.PluginResult {
-      // Only process array responses
-      if (!Array.isArray(response)) {
-        return { context, response };
-      }
-
-      let items: unknown[] = [...response];
-      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: result };
-      }
-
-      return { context, 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 (typeof item !== "object" || item === null) return false;
-        const record = item as Record<string, unknown>;
-        const itemValue = record[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 (typeof a !== "object" || a === null) return 0;
-    if (typeof b !== "object" || b === null) return 0;
-    const aRecord = a as Record<string, unknown>;
-    const bRecord = b as Record<string, unknown>;
-    const aVal = aRecord[sortField];
-    const bVal = bRecord[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,217 +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");
-
-describeFeature(feature, ({ Scenario }) => {
-  let mock: any;
-  let response: any;
-
-  // 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(response.body.data).toHaveLength(count);
-    });
-
-    And("the pagination total should be {int}", (_, total: number) => {
-      expect(response.body.pagination.total).toBe(total);
-    });
-
-    And("the pagination totalPages should be {int}", (_, totalPages: number) => {
-      expect(response.body.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(response.body.data).toHaveLength(count);
-    });
-
-    And("the pagination totalPages should be {int}", (_, totalPages: number) => {
-      expect(response.body.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) => {
-      expect(response.body[0].name).toBe(name);
-    });
-
-    And("the last item name should be {string}", (_, name: string) => {
-      expect(response.body[response.body.length - 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) => {
-      expect(response.body[0].name).toBe(name);
-    });
-
-    And("the last item name should be {string}", (_, name: string) => {
-      expect(response.body[response.body.length - 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(response.body).toHaveLength(count);
-    });
-
-    And("all items should have role {string}", (_, role: string) => {
-      for (const item of response.body) {
-        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(response.body.data).toHaveLength(count);
-    });
-
-    And("the items should be sorted by name ascending", () => {
-      const names = response.body.data.map((item: any) => item.name);
-      const sorted = [...names].sort();
-      expect(names).toEqual(sorted);
-    });
-
-    And("all items should have role {string}", (_, role: string) => {
-      for (const item of response.body.data) {
-        expect(item.role).toBe(role);
-      }
-    });
-
-    And("the pagination total should reflect filtered count", () => {
-      // 11 admins in the dataset
-      expect(response.body.pagination.total).toBe(11);
-    });
-  });
-});