api-json-server 1.0.1 → 1.2.0

package/tests/history.test.ts

@@ -0,0 +1,188 @@
+import { describe, it, expect } from "vitest";
+import { buildTestServer } from "./helpers.js";
+
+const baseSettings = {
+     delayMs: 0,
+     errorRate: 0,
+     errorStatus: 500,
+     errorResponse: { error: "Mock error" }
+};
+
+describe("request history", () => {
+     it("records all requests in history", async () => {
+          const app = buildTestServer({
+               version: 1,
+               settings: baseSettings,
+               endpoints: [
+                    {
+                         method: "GET",
+                         path: "/api/test",
+                         response: { ok: true }
+                    }
+               ]
+          });
+
+          await app.inject({ method: "GET", url: "/api/test?foo=bar" });
+          await app.inject({ method: "GET", url: "/api/test?foo=baz" });
+
+          const historyRes = await app.inject({ method: "GET", url: "/__history" });
+          expect(historyRes.statusCode).toBe(200);
+
+          const history = historyRes.json();
+          expect(history.entries).toBeInstanceOf(Array);
+          expect(history.entries.length).toBeGreaterThanOrEqual(2);
+          expect(history.total).toBeGreaterThanOrEqual(2);
+
+          await app.close();
+     });
+
+     it("records request details including method, url, headers, and body", async () => {
+          const app = buildTestServer({
+               version: 1,
+               settings: baseSettings,
+               endpoints: [
+                    {
+                         method: "POST",
+                         path: "/api/create",
+                         response: { id: 1 }
+                    }
+               ]
+          });
+
+          await app.inject({
+               method: "POST",
+               url: "/api/create",
+               headers: { "content-type": "application/json" },
+               payload: { name: "test" }
+          });
+
+          const historyRes = await app.inject({ method: "GET", url: "/__history?endpoint=/api/create" });
+          const history = historyRes.json();
+          
+          // Should have at least one POST to /api/create
+          const postEntries = history.entries.filter((e: {method: string; path: string}) => 
+               e.method === "POST" && e.path === "/api/create"
+          );
+          expect(postEntries.length).toBeGreaterThan(0);
+          
+          const lastEntry = postEntries[postEntries.length - 1];
+          expect(lastEntry.method).toBe("POST");
+          expect(lastEntry.url).toContain("/api/create");
+          expect(lastEntry.headers["content-type"]).toBe("application/json");
+          expect(lastEntry.body).toEqual({ name: "test" });
+
+          await app.close();
+     });
+
+     it("filters history by endpoint", async () => {
+          const app = buildTestServer({
+               version: 1,
+               settings: baseSettings,
+               endpoints: [
+                    {
+                         method: "GET",
+                         path: "/api/users",
+                         response: { users: [] }
+                    },
+                    {
+                         method: "GET",
+                         path: "/api/posts",
+                         response: { posts: [] }
+                    }
+               ]
+          });
+
+          await app.inject({ method: "GET", url: "/api/users" });
+          await app.inject({ method: "GET", url: "/api/posts" });
+          await app.inject({ method: "GET", url: "/api/users" });
+
+          const historyRes = await app.inject({ method: "GET", url: "/__history?endpoint=/api/users" });
+          const history = historyRes.json();
+
+          expect(history.entries.every((e: { path: string }) => e.path === "/api/users")).toBe(true);
+
+          await app.close();
+     });
+
+     it("filters history by method", async () => {
+          const app = buildTestServer({
+               version: 1,
+               settings: baseSettings,
+               endpoints: [
+                    {
+                         method: "GET",
+                         path: "/api/data",
+                         response: { data: "get" }
+                    },
+                    {
+                         method: "POST",
+                         path: "/api/data",
+                         response: { data: "post" }
+                    }
+               ]
+          });
+
+          await app.inject({ method: "GET", url: "/api/data" });
+          await app.inject({ method: "POST", url: "/api/data" });
+          await app.inject({ method: "GET", url: "/api/data" });
+
+          const historyRes = await app.inject({ method: "GET", url: "/__history?method=POST" });
+          const history = historyRes.json();
+
+          expect(history.entries.every((e: { method: string }) => e.method === "POST")).toBe(true);
+
+          await app.close();
+     });
+
+     it("clears history on DELETE request", async () => {
+          const app = buildTestServer({
+               version: 1,
+               settings: baseSettings,
+               endpoints: [
+                    {
+                         method: "GET",
+                         path: "/api/test",
+                         response: { ok: true }
+                    }
+               ]
+          });
+
+          await app.inject({ method: "GET", url: "/api/test" });
+
+          const beforeClear = await app.inject({ method: "GET", url: "/__history" });
+          expect(beforeClear.json().entries.length).toBeGreaterThan(0);
+
+          await app.inject({ method: "DELETE", url: "/__history" });
+
+          const afterClear = await app.inject({ method: "GET", url: "/__history" });
+          // Should only have the history requests themselves
+          expect(afterClear.json().entries.length).toBeLessThanOrEqual(2);
+
+          await app.close();
+     });
+
+     it("limits history entries with limit parameter", async () => {
+          const app = buildTestServer({
+               version: 1,
+               settings: baseSettings,
+               endpoints: [
+                    {
+                         method: "GET",
+                         path: "/api/test",
+                         response: { ok: true }
+                    }
+               ]
+          });
+
+          for (let i = 0; i < 10; i++) {
+               await app.inject({ method: "GET", url: "/api/test" });
+          }
+
+          const historyRes = await app.inject({ method: "GET", url: "/__history?limit=3" });
+          const history = historyRes.json();
+
+          expect(history.entries.length).toBeLessThanOrEqual(3);
+
+          await app.close();
+     });
+});

package/tests/matching.test.ts

@@ -0,0 +1,245 @@
+import { describe, it, expect } from "vitest";
+import { buildTestServer } from "./helpers.js";
+
+const baseSettings = {
+     delayMs: 0,
+     errorRate: 0,
+     errorStatus: 500,
+     errorResponse: { error: "Mock error" }
+};
+
+describe("matching rules", () => {
+     it("returns 404 when endpoint-level query match fails", async () => {
+          const app = buildTestServer({
+               version: 1,
+               settings: baseSettings,
+               endpoints: [
+                    {
+                         method: "GET",
+                         path: "/search",
+                         match: { query: { type: "premium" } },
+                         response: { ok: true }
+                    }
+               ]
+          });
+
+          const res = await app.inject({ method: "GET", url: "/search?type=basic" });
+          expect(res.statusCode).toBe(404);
+
+          await app.close();
+     });
+
+     it("matches endpoint-level body rules for POST", async () => {
+          const app = buildTestServer({
+               version: 1,
+               settings: baseSettings,
+               endpoints: [
+                    {
+                         method: "POST",
+                         path: "/login",
+                         match: { body: { password: "secret" } },
+                         response: { ok: true }
+                    }
+               ]
+          });
+
+          const ok = await app.inject({ method: "POST", url: "/login", payload: { password: "secret" } });
+          expect(ok.statusCode).toBe(200);
+
+          const bad = await app.inject({ method: "POST", url: "/login", payload: { password: "wrong" } });
+          expect(bad.statusCode).toBe(404);
+
+          await app.close();
+     });
+
+     it("uses first matching variant when multiple variants match", async () => {
+          const app = buildTestServer({
+               version: 1,
+               settings: baseSettings,
+               endpoints: [
+                    {
+                         method: "POST",
+                         path: "/variants",
+                         response: { ok: true, source: "base" },
+                         variants: [
+                              {
+                                   name: "first",
+                                   match: { body: { role: "admin" } },
+                                   status: 403,
+                                   response: { ok: false, source: "first" }
+                              },
+                              {
+                                   name: "second",
+                                   match: { body: { role: "admin" } },
+                                   status: 200,
+                                   response: { ok: true, source: "second" }
+                              }
+                         ]
+                    }
+               ]
+          });
+
+          const res = await app.inject({ method: "POST", url: "/variants", payload: { role: "admin" } });
+          expect(res.statusCode).toBe(403);
+          expect(res.json()).toEqual({ ok: false, source: "first" });
+
+          await app.close();
+     });
+
+     it("falls back to endpoint response when no variant matches", async () => {
+          const app = buildTestServer({
+               version: 1,
+               settings: baseSettings,
+               endpoints: [
+                    {
+                         method: "POST",
+                         path: "/variants",
+                         response: { ok: true, source: "base" },
+                         variants: [
+                              {
+                                   name: "only",
+                                   match: { body: { role: "admin" } },
+                                   status: 201,
+                                   response: { ok: true, source: "variant" }
+                              }
+                         ]
+                    }
+               ]
+          });
+
+          const res = await app.inject({ method: "POST", url: "/variants", payload: { role: "user" } });
+          expect(res.statusCode).toBe(200);
+          expect(res.json()).toEqual({ ok: true, source: "base" });
+
+          await app.close();
+     });
+
+     it("rejects array query values for match rules", async () => {
+          const app = buildTestServer({
+               version: 1,
+               settings: baseSettings,
+               endpoints: [
+                    {
+                         method: "GET",
+                         path: "/search",
+                         match: { query: { type: "premium" } },
+                         response: { ok: true }
+                    }
+               ]
+          });
+
+          const res = await app.inject({ method: "GET", url: "/search?type=premium&type=basic" });
+          expect(res.statusCode).toBe(404);
+
+          await app.close();
+     });
+
+     it("matches request headers (case-insensitive)", async () => {
+          const app = buildTestServer({
+               version: 1,
+               settings: baseSettings,
+               endpoints: [
+                    {
+                         method: "GET",
+                         path: "/api/data",
+                         match: { headers: { Authorization: "Bearer token123" } },
+                         response: { ok: true, data: "secure" }
+                    }
+               ]
+          });
+
+          const ok = await app.inject({
+               method: "GET",
+               url: "/api/data",
+               headers: { authorization: "Bearer token123" }
+          });
+          expect(ok.statusCode).toBe(200);
+          expect(ok.json()).toEqual({ ok: true, data: "secure" });
+
+          const bad = await app.inject({
+               method: "GET",
+               url: "/api/data",
+               headers: { authorization: "Bearer wrong" }
+          });
+          expect(bad.statusCode).toBe(404);
+
+          await app.close();
+     });
+
+     it("matches cookies", async () => {
+          const app = buildTestServer({
+               version: 1,
+               settings: baseSettings,
+               endpoints: [
+                    {
+                         method: "GET",
+                         path: "/profile",
+                         match: { cookies: { sessionId: "abc123" } },
+                         response: { user: "john" }
+                    }
+               ]
+          });
+
+          const ok = await app.inject({
+               method: "GET",
+               url: "/profile",
+               headers: { cookie: "sessionId=abc123" }
+          });
+          expect(ok.statusCode).toBe(200);
+          expect(ok.json()).toEqual({ user: "john" });
+
+          const bad = await app.inject({
+               method: "GET",
+               url: "/profile",
+               headers: { cookie: "sessionId=wrong" }
+          });
+          expect(bad.statusCode).toBe(404);
+
+          await app.close();
+     });
+
+     it("combines query, body, headers, and cookies in match rules", async () => {
+          const app = buildTestServer({
+               version: 1,
+               settings: baseSettings,
+               endpoints: [
+                    {
+                         method: "POST",
+                         path: "/api/action",
+                         match: {
+                              query: { type: "premium" },
+                              body: { action: "delete" },
+                              headers: { "X-API-Key": "secret" },
+                              cookies: { session: "valid" }
+                         },
+                         response: { ok: true }
+                    }
+               ]
+          });
+
+          const ok = await app.inject({
+               method: "POST",
+               url: "/api/action?type=premium",
+               headers: {
+                    "x-api-key": "secret",
+                    cookie: "session=valid"
+               },
+               payload: { action: "delete" }
+          });
+          expect(ok.statusCode).toBe(200);
+
+          // Missing one of the requirements
+          const bad = await app.inject({
+               method: "POST",
+               url: "/api/action?type=premium",
+               headers: {
+                    "x-api-key": "secret",
+                    cookie: "session=wrong"
+               },
+               payload: { action: "delete" }
+          });
+          expect(bad.statusCode).toBe(404);
+
+          await app.close();
+     });
+});

package/tests/server.test.ts

@@ -0,0 +1,73 @@
+import { describe, it, expect } from "vitest";
+import { buildTestServerFromFixture, loadFixture } from "./helpers.js";
+
+describe("mockserve - core behavior", () => {
+     it("renders templates using path params + query", async () => {
+          const app = await buildTestServerFromFixture("tests/fixtures/spec.basic.json");
+
+          const res = await app.inject({
+               method: "GET",
+               url: "/users/42?type=basic"
+          });
+
+          expect(res.statusCode).toBe(200);
+          expect(res.json()).toEqual({ id: "42", type: "basic" });
+
+          await app.close();
+     });
+
+     it("enforces endpoint-level match rules (query match -> 404 when mismatch)", async () => {
+          const app = await buildTestServerFromFixture("tests/fixtures/spec.basic.json");
+
+          const ok = await app.inject({ method: "GET", url: "/search?type=premium" });
+          expect(ok.statusCode).toBe(200);
+
+          const bad = await app.inject({ method: "GET", url: "/search?type=basic" });
+          expect(bad.statusCode).toBe(404);
+
+          await app.close();
+     });
+
+     it("returns variant response when variant match is satisfied", async () => {
+          const app = await buildTestServerFromFixture("tests/fixtures/spec.basic.json");
+
+          const res = await app.inject({
+               method: "POST",
+               url: "/login",
+               payload: { email: "a@b.com", password: "wrong" }
+          });
+
+          expect(res.statusCode).toBe(401);
+          expect(res.json()).toEqual({ ok: false, error: "Invalid credentials" });
+
+          await app.close();
+     });
+
+     it("falls back to base endpoint response when no variant matches", async () => {
+          const app = await buildTestServerFromFixture("tests/fixtures/spec.basic.json");
+
+          const res = await app.inject({
+               method: "POST",
+               url: "/login",
+               payload: { email: "a@b.com", password: "ok" }
+          });
+
+          expect(res.statusCode).toBe(200);
+          expect(res.json()).toEqual({ ok: true, message: "default" });
+
+          await app.close();
+     });
+
+     it("exposes /__spec for debugging", async () => {
+          const app = await buildTestServerFromFixture("tests/fixtures/spec.basic.json");
+
+          const res = await app.inject({ method: "GET", url: "/__spec" });
+
+          expect(res.statusCode).toBe(200);
+          const body = res.json();
+          expect(body.spec.version).toBe(1);
+          expect(body.meta.specPath).toBe("tests/fixtures/spec.basic.json");
+
+          await app.close();
+     });
+});

package/tests/template.test.ts

@@ -0,0 +1,90 @@
+import { describe, it, expect } from "vitest";
+import { buildTestServer } from "./helpers.js";
+
+const baseSettings = {
+     delayMs: 0,
+     errorRate: 0,
+     errorStatus: 500,
+     errorResponse: { error: "Mock error" }
+};
+
+describe("template rendering", () => {
+     it("renders params and query placeholders in responses", async () => {
+          const app = buildTestServer({
+               version: 1,
+               settings: baseSettings,
+               endpoints: [
+                    {
+                         method: "GET",
+                         path: "/users/:id",
+                         response: {
+                              id: "{{params.id}}",
+                              type: "{{query.type}}",
+                              nested: { tag: "{{query.tag}}" }
+                         }
+                    }
+               ]
+          });
+
+          const res = await app.inject({ method: "GET", url: "/users/42?type=basic&tag=vip" });
+          expect(res.statusCode).toBe(200);
+          expect(res.json()).toEqual({ id: "42", type: "basic", nested: { tag: "vip" } });
+
+          await app.close();
+     });
+
+     it("renders body placeholders in responses", async () => {
+          const app = buildTestServer({
+               version: 1,
+               settings: baseSettings,
+               endpoints: [
+                    {
+                         method: "POST",
+                         path: "/echo",
+                         response: {
+                              email: "{{body.email}}",
+                              name: "{{body.profile.name}}"
+                         }
+                    }
+               ]
+          });
+
+          const res = await app.inject({
+               method: "POST",
+               url: "/echo",
+               payload: { email: "user@example.com", profile: { name: "Mia" } }
+          });
+
+          expect(res.statusCode).toBe(200);
+          expect(res.json()).toEqual({ email: "user@example.com", name: "Mia" });
+
+          await app.close();
+     });
+
+     it("renders arrays of templated items", async () => {
+          const app = buildTestServer({
+               version: 1,
+               settings: baseSettings,
+               endpoints: [
+                    {
+                         method: "GET",
+                         path: "/tags/:id",
+                         response: {
+                              id: "{{params.id}}",
+                              tags: ["{{query.primary}}", "{{query.secondary}}"]
+                         }
+                    }
+               ]
+          });
+
+          const res = await app.inject({
+               method: "GET",
+               url: "/tags/abc?primary=gold&secondary=silver"
+          });
+
+          expect(res.statusCode).toBe(200);
+          expect(res.json()).toEqual({ id: "abc", tags: ["gold", "silver"] });
+
+          await app.close();
+     });
+});

package/src/template.ts

@@ -1,61 +0,0 @@
-type TemplateContext = {
-     params: Record<string, unknown>;
-     query: Record<string, unknown>;
-     body: unknown;
-};
-
-function getPath(obj: unknown, path: string): unknown {
-     if (!path) return undefined;
-
-     const parts = path.split(".");
-     let cur: any = obj;
-
-     for (const p of parts) {
-          if (cur == null) return undefined;
-          cur = cur[p];
-     }
-     return cur;
-}
-
-function renderStringTemplate(input: string, ctx: TemplateContext): string {
-     // Replaces occurrences like {{params.id}} or {{query.type}} or {{body.email}}
-     return input.replace(/\{\{\s*([a-zA-Z]+)\.([a-zA-Z0-9_.]+)\s*\}\}/g, (_m, root, path) => {
-          let source: unknown;
-          if (root === "params") source = ctx.params;
-          else if (root === "query") source = ctx.query;
-          else if (root === "body") source = ctx.body;
-          else return "";
-
-          const value = root === "body" ? getPath(source, path) : getPath(source, path);
-
-          if (value === undefined || value === null) return "";
-          if (typeof value === "string") return value;
-          if (typeof value === "number" || typeof value === "boolean") return String(value);
-
-          // For objects/arrays, stringify to keep output valid (still a string substitution)
-          try {
-               return JSON.stringify(value);
-          } catch {
-               return "";
-          }
-     });
-}
-
-export function renderTemplate(value: unknown, ctx: TemplateContext): unknown {
-     if (typeof value === "string") return renderStringTemplate(value, ctx);
-
-     if (Array.isArray(value)) {
-          return value.map((v) => renderTemplate(v, ctx));
-     }
-
-     if (value && typeof value === "object") {
-          const out: Record<string, unknown> = {};
-          for (const [k, v] of Object.entries(value as Record<string, unknown>)) {
-               out[k] = renderTemplate(v, ctx);
-          }
-          return out;
-     }
-
-     // numbers, booleans, null, undefined stay as-is
-     return value;
-}