@benclmnt/postmock 0.0.4 → 0.0.5

package/dist/src/control/endpoints/core.js

@@ -39,7 +39,24 @@ defineControl({
 function clockState(clock) {
     return { now: formatTimestamp(clock.now(), "utc"), pending: clock.pending };
 }
-const requestMatch = z.object({ method: z.string(), path: z.string().startsWith("/") });
+const requestMatch = z.object({
+    method: z.string(),
+    path: z.string().startsWith("/"),
+    // The domain part of a parsed address: DNS labels with a letter, so no IP, literal or trailing dot.
+    recipientDomain: z
+        .string()
+        .regex(/^(?=.*[a-z])[a-z0-9-]+(\.[a-z0-9-]+)*$/i)
+        .transform((d) => d.toLowerCase())
+        .optional(),
+});
+function requestRule(match, times) {
+    return {
+        method: match.method,
+        path: match.path,
+        recipientDomain: match.recipientDomain,
+        remaining: times,
+    };
+}
 defineControl({
     method: "POST",
     path: "/control/latency",
@@ -50,9 +67,7 @@ defineControl({
             ms: z.int().positive(),
         }), ctx.body);
         ctx.store.state.latencies.push({
-            method: match.method,
-            path: match.path,
-            remaining: times,
+            ...requestRule(match, times),
             ms,
         });
         return { latencies: ctx.store.state.latencies.length };
@@ -75,9 +90,7 @@ defineControl({
     handler: (ctx) => {
         const { match, times, reply } = controlInput(faultSchema, ctx.body);
         ctx.store.state.faults.push({
-            method: match.method,
-            path: match.path,
-            remaining: times,
+            ...requestRule(match, times),
             reply: reply === "timeout" || reply === "reset"
                 ? reply
                 : faultError(controlInput(errorReply, reply)),

package/dist/src/http/app.js

@@ -12,7 +12,8 @@ export function createApiApp(runtime) {
     app.all("*", async (c) => {
         const request = c.req.raw;
         const url = new URL(request.url);
-        const fault = await applyFault(runtime, request.method, url.pathname, c.env);
+        const bytes = await request.arrayBuffer();
+        const fault = await applyFault(runtime, { method: request.method, pathname: url.pathname, body: bytes }, c.env);
         if (fault)
             return fault;
         const matched = apiRoutes.match(request.method, url.pathname);
@@ -22,7 +23,7 @@ export function createApiApp(runtime) {
         const { route, params } = matched;
         try {
             const auth = authenticate(route.auth, request.headers, runtime.store.state, `${route.method} ${route.path}`, runtime.clock.now());
-            const body = decodeJsonBody(await request.arrayBuffer());
+            const body = decodeJsonBody(bytes);
             const result = await route.handler({
                 ...runtime,
                 method: route.method,

package/dist/src/http/faults.d.ts

@@ -1,8 +1,14 @@
 import type { HttpBindings } from "@hono/node-server";
 import type { Runtime } from "../runtime.ts";
+/** What a rule can match on: the route, and the send body for a recipient domain. */
+export interface RuleRequest {
+    method: string;
+    pathname: string;
+    body: ArrayBuffer;
+}
 /**
  * Holds the request for the first matching latency rule, then applies the first matching fault
  * (docs/09 §5 `POST /control/latency`, `POST /control/faults`). Each match uses one of the rule's
  * `times`. `timeout` holds the request open until the client gives up; `reset` destroys the socket.
  */
-export declare function applyFault({ store, clock }: Runtime, method: string, pathname: string, env: HttpBindings): Promise<Response | undefined>;
+export declare function applyFault({ store, clock }: Runtime, request: RuleRequest, env: HttpBindings): Promise<Response | undefined>;

package/dist/src/http/faults.js

@@ -1,4 +1,5 @@
 import { ApiError } from "../errors.js";
+import { parseAddressList } from "../pipeline/addresses.js";
 import { errorResponse } from "./respond.js";
 import { RouteTable } from "./routes.js";
 /**
@@ -6,25 +7,66 @@ import { RouteTable } from "./routes.js";
  * (docs/09 §5 `POST /control/latency`, `POST /control/faults`). Each match uses one of the rule's
  * `times`. `timeout` holds the request open until the client gives up; `reset` destroys the socket.
  */
-export async function applyFault({ store, clock }, method, pathname, env) {
-    const latency = take(store.state.latencies, method, pathname);
+export async function applyFault({ store, clock }, request, env) {
+    let domains;
+    const mailsDomain = (domain) => {
+        domains ??= recipientDomains(request.body);
+        return domains.has(domain);
+    };
+    const latency = take(store.state.latencies, request, mailsDomain);
     if (latency)
         await clock.hold(latency.ms);
-    const fault = take(store.state.faults, method, pathname);
+    const fault = take(store.state.faults, request, mailsDomain);
     return fault && reply(fault, env);
 }
-function take(rules, method, pathname) {
+function take(rules, request, mailsDomain) {
     const rule = rules.find((r) => {
         if (r.remaining <= 0)
             return false;
         const table = new RouteTable();
         table.add({ method: r.method.toUpperCase(), path: r.path });
-        return table.match(method, pathname) !== undefined;
+        if (table.match(request.method, request.pathname) === undefined)
+            return false;
+        return r.recipientDomain === undefined || mailsDomain(r.recipientDomain);
     });
     if (rule)
         rule.remaining -= 1;
     return rule;
 }
+/**
+ * The lower-case domains of every To, Cc and Bcc address in a send body: one message, a batch
+ * array, or a `Messages` list. Keys match without case (docs/08 R8). A body that is not JSON, or a
+ * field with a malformed entry, gives none; its route answers the Postmark error.
+ */
+function recipientDomains(bytes) {
+    let body;
+    try {
+        body = JSON.parse(new TextDecoder("utf-8").decode(bytes));
+    }
+    catch {
+        return new Set();
+    }
+    const list = field(body, "Messages");
+    const messages = Array.isArray(body) ? body : Array.isArray(list) ? list : [body];
+    const domains = new Set();
+    for (const message of messages) {
+        for (const name of ["To", "Cc", "Bcc"]) {
+            const raw = field(message, name);
+            if (typeof raw !== "string")
+                continue;
+            for (const { Email } of parseAddressList(raw) ?? []) {
+                domains.add(Email.slice(Email.lastIndexOf("@") + 1).toLowerCase());
+            }
+        }
+    }
+    return domains;
+}
+function field(value, name) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        return undefined;
+    const key = Object.keys(value).find((k) => k.toLowerCase() === name.toLowerCase());
+    return key === undefined ? undefined : value[key];
+}
 async function reply(fault, env) {
     const { reply } = fault;
     if (reply === "reset") {

package/dist/src/state/types.d.ts

@@ -526,6 +526,8 @@ export interface RequestRule {
     method: string;
     /** `/email`, `/templates/:id` */
     path: string;
+    /** Lower case. Only a request with a To, Cc or Bcc address at this domain matches. */
+    recipientDomain: string | undefined;
     remaining: number;
 }
 export interface Fault extends RequestRule {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@benclmnt/postmock",
-  "version": "0.0.4",
+  "version": "0.0.5",
   "description": "A mock Postmark server for testing code that sends email through Postmark",
   "license": "MIT",
   "repository": {