api-json-server 1.0.1 → 1.1.0

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;
-}