@schmock/query 2.0.0 → 2.0.1

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,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":"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"}

package/dist/index.js

@@ -1 +1 @@
-function W(z){return{name:"query",version:"1.0.0",process(A,j){if(!Array.isArray(j))return{context:A,response:j};let C=[...j],D=A.query||{};if(z.filtering)C=R(C,D,z.filtering);if(z.sorting)C=T(C,D,z.sorting);if(z.pagination){let B=U(C,D,z.pagination);return{context:A,response:B}}return{context:A,response:C}}}}function R(z,A,j){let C=j.filterPrefix??"filter",D=z;for(let B of j.allowed){let Q=`${C}[${B}]`,J=`${C}.${B}`,G=A[Q]??A[J]??A[B];if(G!==void 0)D=D.filter((M)=>{let E=M[B];if(E===void 0)return!1;return String(E)===G})}return D}function T(z,A,j){let C=j.sortParam??"sort",D=j.orderParam??"order",B=A[C]??j.default,J=(A[D]??j.defaultOrder??"asc")==="desc"?"desc":"asc";if(!B)return z;if(!j.allowed.includes(B))return z;return z.sort((G,M)=>{let E=G[B],H=M[B];if(E===H)return 0;if(E===void 0)return 1;if(H===void 0)return-1;let N;if(typeof E==="number"&&typeof H==="number")N=E-H;else N=String(E).localeCompare(String(H));return J==="desc"?-N:N})}function U(z,A,j){let C=j.pageParam??"page",D=j.limitParam??"limit",B=j.defaultLimit??10,Q=j.maxLimit??100,J=Math.max(1,Number.parseInt(A[C]||"1",10)||1),G=Math.min(Q,Math.max(1,Number.parseInt(A[D]||String(B),10)||B)),M=z.length,E=Math.ceil(M/G),H=(J-1)*G;return{data:z.slice(H,H+G),pagination:{page:J,limit:G,total:M,totalPages:E}}}export{W as queryPlugin};
+var B="2.0.1";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};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@schmock/query",
   "description": "Pagination, filtering, and sorting plugin for Schmock",
-  "version": "2.0.0",
+  "version": "2.0.1",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",

package/src/index.test.ts

@@ -5,7 +5,7 @@ describe("queryPlugin", () => {
   it("creates a plugin with correct name", () => {
     const plugin = queryPlugin({ pagination: {} });
     expect(plugin.name).toBe("query");
-    expect(plugin.version).toBe("1.0.0");
+    expect(plugin.version).toBe("2.0.1");
   });
 
   it("passes through non-array responses", async () => {
@@ -131,4 +131,334 @@ describe("queryPlugin", () => {
 
     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,5 +1,7 @@
 /// <reference path="../../core/schmock.d.ts" />
 
+import { version as packageVersion } from "../package.json";
+
 interface PaginationOptions {
   /** Default items per page (default: 10) */
   defaultLimit?: number;
@@ -40,18 +42,18 @@ interface QueryPluginOptions {
 export function queryPlugin(options: QueryPluginOptions): Schmock.Plugin {
   return {
     name: "query",
-    version: "1.0.0",
+    version: packageVersion,
 
     process(
       context: Schmock.PluginContext,
-      response?: any,
+      response?: unknown,
     ): Schmock.PluginResult {
       // Only process array responses
       if (!Array.isArray(response)) {
         return { context, response };
       }
 
-      let items = [...response];
+      let items: unknown[] = [...response];
       const query = context.query || {};
 
       // Apply filtering
@@ -76,10 +78,10 @@ export function queryPlugin(options: QueryPluginOptions): Schmock.Plugin {
 }
 
 function applyFiltering(
-  items: any[],
+  items: unknown[],
   query: Record<string, string>,
   options: FilteringOptions,
-): any[] {
+): unknown[] {
   const prefix = options.filterPrefix ?? "filter";
   let result = items;
 
@@ -93,7 +95,9 @@ function applyFiltering(
 
     if (value !== undefined) {
       result = result.filter((item) => {
-        const itemValue = item[field];
+        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;
@@ -105,10 +109,10 @@ function applyFiltering(
 }
 
 function applySorting(
-  items: any[],
+  items: unknown[],
   query: Record<string, string>,
   options: SortingOptions,
-): any[] {
+): unknown[] {
   const sortParam = options.sortParam ?? "sort";
   const orderParam = options.orderParam ?? "order";
   const sortField = query[sortParam] ?? options.default;
@@ -121,8 +125,12 @@ function applySorting(
   if (!options.allowed.includes(sortField)) return items;
 
   return items.sort((a, b) => {
-    const aVal = a[sortField];
-    const bVal = b[sortField];
+    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;
@@ -140,7 +148,7 @@ function applySorting(
 }
 
 interface PaginatedResult {
-  data: any[];
+  data: unknown[];
   pagination: {
     page: number;
     limit: number;
@@ -150,7 +158,7 @@ interface PaginatedResult {
 }
 
 function applyPagination(
-  items: any[],
+  items: unknown[],
   query: Record<string, string>,
   options: PaginationOptions,
 ): PaginatedResult {

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

@@ -79,30 +79,6 @@ describeFeature(feature, ({ Scenario }) => {
     });
   });
 
-  Scenario("Pagination beyond last page returns empty", ({ 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 10", async () => {
-      response = await mock.handle("GET", "/items", {
-        query: { page: "10" },
-      });
-    });
-
-    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);
-    });
-  });
-
   Scenario("Sort items ascending by name", ({ Given, When, Then, And }) => {
     Given("I create a mock with named items and sorting plugin", () => {
       mock = schmock();