@pplethai/cli 0.6.0 → 0.8.0

package/templates/golden-path/test/dev-call-service.test.ts

@@ -0,0 +1,279 @@
+// Offline callService (issue #261, ADR-0026). Vitest never lets callService
+// read `.pple/`. These tests feed the same matcher a fixture glob and read
+// the status, headers, and body a Builder would see.
+
+import { beforeAll, describe, expect, it, vi } from "vitest";
+import { platformError } from "../src/call-service";
+import { answerFromOverlay, matchMockCase, type OverlayCall } from "../src/dev-call-service";
+
+const overlay: Record<string, unknown> = import.meta.glob("./fixtures/overlay/**/*", {
+  eager: true,
+  query: "?raw",
+  import: "default",
+});
+
+beforeAll(() => {
+  const keys = Object.keys(overlay).join("\n");
+  expect(keys).toContain("shop/orders/mocks/responses.json");
+  expect(keys).toContain("shop/orders/entry.md");
+  expect(keys).toContain("platform/legal-identity/mocks/responses.json");
+});
+
+const cases = [
+  null,
+  { method: "GET", path: "/items/:id", persona: "hq-staff", body: "hq" },
+  { method: "GET", path: "/items/:id", persona: ["delegate", "platform-admin"], body: "listed" },
+  { method: "GET", path: "items/:id", body: "open" },
+  { method: "POST", path: "/", body: "root" },
+  { path: "/files/*", body: "files" },
+  { method: "GET", path: "/empty", persona: [], body: "no" },
+  { method: "PUT", path: "/a/*/b", body: "bad" },
+  { method: "DELETE", body: "any" },
+];
+
+describe("matchMockCase", () => {
+  it.each([
+    ["first matching persona wins", "GET", "/items/1", "hq-staff", "hq"],
+    ["a persona list matches", "GET", "/items/1", "delegate", "listed"],
+    ["a persona the Builder added gets only an unscoped case", "GET", "/items/1", "intern", "open"],
+    ["the query is not part of the match", "GET", "/items/1?limit=2", "hq-staff", "hq"],
+    ["a pattern without a leading slash matches a slash tail", "GET", "/items/9", "unverified", "open"],
+    ["a request without a leading slash matches a slash pattern", "get", "items/9", "hq-staff", "hq"],
+    ["a param does not swallow a second segment", "GET", "/items/1/extra", "hq-staff", null],
+    ["/ is the empty tail", "POST", "", "hq-staff", "root"],
+    ["a slash tail is the same root", "POST", "/", "intern", "root"],
+    ["a query on the root stays the root", "POST", "?dry=1", "hq-staff", "root"],
+    ["the root does not match a longer tail", "POST", "/items", "hq-staff", null],
+    ["a trailing star matches the rest of the tail", "POST", "/files/a/b", "intern", "files"],
+    ["a trailing star does not match an empty rest", "GET", "/files", "hq-staff", null],
+    ["an omitted path matches whatever is left", "DELETE", "/nope", "intern", "any"],
+    ["an omitted path matches the root too", "DELETE", "", "hq-staff", "any"],
+    ["an empty persona list matches nobody", "GET", "/empty", "hq-staff", null],
+    ["a star that is not the last segment matches nothing", "PUT", "/a/x/b", "hq-staff", null],
+  ] as const)("%s", (_name, method, path, persona, body) => {
+    const matched = matchMockCase(cases, method, path, persona);
+    expect(matched?.body ?? null).toBe(body);
+  });
+
+  it("returns the earlier case when two would match", () => {
+    const matched = matchMockCase(
+      [
+        { method: "GET", path: "/dup", body: "first" },
+        { method: "GET", path: "/dup", body: "second" },
+      ],
+      "GET",
+      "/dup",
+      "hq-staff",
+    );
+    expect(matched?.body).toBe("first");
+  });
+});
+
+describe("overlay fixture", () => {
+  it("matches method, path and persona, and marks the mock", async () => {
+    const res = await call({ entry: "shop/orders", path: "/items/7?limit=2", method: "GET", persona: "hq-staff", userToken: "t" });
+    expect(res.status).toBe(200);
+    expect(res.headers.get("x-pple-mock")).toBe("shop/orders");
+    expect(res.headers.get("x-pple-error")).toBeNull();
+    expect(res.headers.get("x-shop")).toBe("hq");
+    expect(platformError(res)).toBeNull();
+    expect(await res.json()).toEqual({ item: "hq" });
+  });
+
+  it("uses the first match, then an unscoped case for a persona the Builder added", async () => {
+    const listed = await call({ entry: "shop/orders", path: "/items/7", method: "GET", persona: "delegate", userToken: "t" });
+    expect(await listed.json()).toEqual({ item: "listed" });
+
+    const added = await call({ entry: "shop/orders", path: "/items/7", method: "GET", persona: "intern", userToken: "t" });
+    expect(added.headers.get("x-pple-mock")).toBe("shop/orders");
+    expect(await added.json()).toEqual({ item: "open" });
+  });
+
+  it("treats / as the entry root and sends a string body as text", async () => {
+    const root = await call({ entry: "shop/orders", path: "", method: "POST", persona: "hq-staff", userToken: "t" });
+    expect(root.status).toBe(201);
+    expect(root.headers.get("x-pple-mock")).toBe("shop/orders");
+    expect(await root.json()).toEqual({ created: true });
+
+    const longer = await call({ entry: "shop/orders", path: "/created", method: "POST", persona: "hq-staff", userToken: "t" });
+    expect(longer.status).toBe(404);
+    expect(longer.headers.get("x-pple-error")).toBe("no_mock");
+
+    const files = await call({ entry: "shop/orders", path: "/files/a/b", method: "GET", persona: "intern", userToken: "t" });
+    expect(files.headers.get("content-type")).toContain("text/plain");
+    expect(await files.text()).toBe("listed");
+  });
+
+  it("answers a userToken none entry with no token", async () => {
+    const res = await call({ entry: "shop/catalog", path: "/search", method: "GET", persona: "hq-staff" });
+    expect(res.status).toBe(200);
+    expect(res.headers.get("x-pple-mock")).toBe("shop/catalog");
+    expect(await res.json()).toEqual({ ok: true });
+  });
+
+  it("refuses a required entry that was called with no token", async () => {
+    for (const userToken of [undefined, "", "  "]) {
+      const res = await call({ entry: "shop/orders", path: "/items/7", method: "GET", persona: "hq-staff", userToken });
+      expect(res.status).toBe(401);
+      expect(res.headers.get("x-pple-error")).toBe("user_token_invalid");
+      expect(res.headers.get("x-pple-mock")).toBeNull();
+      expect(platformError(res)).toBe("user_token_invalid");
+      expect(await res.json()).toEqual({ error: "user_token_invalid" });
+    }
+  });
+
+  it("says when the entry is missing, and when the route is", async () => {
+    const missing = await call({ entry: "shop/missing", path: "/items/1", method: "GET", persona: "hq-staff", userToken: "t" });
+    expect(missing.status).toBe(404);
+    expect(missing.headers.get("x-pple-error")).toBe("no_mock");
+    expect(missing.headers.get("x-pple-mock")).toBeNull();
+    expect(platformError(missing)).toBeNull();
+    const missingBody = await missing.json<{ error: string; message: string }>();
+    expect(missingBody.error).toBe("no_mock");
+    expect(missingBody.message).toContain("pple registry");
+    expect(missingBody.message).toContain(".pple/registry/");
+    expect(missingBody.message).toMatch(/[\u0E00-\u0E7F]/);
+
+    const route = await call({ entry: "shop/orders", path: "/nope", method: "GET", persona: "hq-staff", userToken: "t" });
+    const routeBody = await route.json<{ error: string; message: string }>();
+    expect(route.status).toBe(404);
+    expect(route.headers.get("x-pple-error")).toBe("no_mock");
+    expect(routeBody.error).toBe("no_mock");
+    expect(routeBody.message).toContain("pple registry");
+    expect(routeBody.message).toContain("GET /nope");
+    expect(routeBody.message).toMatch(/[\u0E00-\u0E7F]/);
+    expect(routeBody.message).not.toContain(".pple/registry/");
+  });
+
+  it("keeps a root mock off every other tail", async () => {
+    const root = await call({
+      entry: "platform/legal-identity",
+      path: "",
+      method: "POST",
+      persona: "kyc-verified-nonmember",
+      userToken: "t",
+    });
+    expect(await root.json()).toEqual({ source: "default" });
+
+    const member = await call({
+      entry: "platform/legal-identity",
+      path: "/",
+      method: "POST",
+      persona: "hq-staff",
+      userToken: "t",
+    });
+    expect(await member.json()).toEqual({ source: "membership" });
+
+    const other = await call({
+      entry: "platform/legal-identity",
+      path: "/extra",
+      method: "POST",
+      persona: "hq-staff",
+      userToken: "t",
+    });
+    expect(other.status).toBe(404);
+    expect(other.headers.get("x-pple-error")).toBe("no_mock");
+  });
+});
+
+describe("DEV_REGISTRY_ERROR", () => {
+  const statuses: [string, number][] = [
+    ["invalid_app_key", 401],
+    ["not_listed", 404],
+    ["not_granted", 403],
+    ["needs_beta", 403],
+    ["user_token_invalid", 401],
+    ["identity_unavailable", 503],
+    ["provider_unavailable", 502],
+    ["provider_timeout", 504],
+    ["method_not_allowed", 405],
+    ["not_found", 404],
+    ["invalid_query", 400],
+    ["level_not_met", 403],
+  ];
+
+  it.each(statuses)("global %s is %i", async (code, status) => {
+    const res = await call({
+      entry: "shop/orders",
+      path: "/items/1",
+      method: "GET",
+      persona: "hq-staff",
+      userToken: "t",
+      devRegistryError: code,
+    });
+    expect(res.status).toBe(status);
+    expect(res.headers.get("x-pple-error")).toBe(code);
+    expect(res.headers.get("x-pple-mock")).toBeNull();
+    expect(platformError(res)).toBe(code);
+    expect(await res.json()).toEqual({ error: code });
+  });
+
+  it("lets a per-entry code win over a global one, in either order", async () => {
+    for (const spec of ["not_granted, shop/orders=provider_timeout", "shop/orders = provider_timeout, not_granted"]) {
+      const orders = await call({
+        entry: "shop/orders",
+        path: "/items/1",
+        method: "GET",
+        persona: "hq-staff",
+        userToken: "t",
+        devRegistryError: spec,
+      });
+      expect(orders.status).toBe(504);
+      expect(orders.headers.get("x-pple-error")).toBe("provider_timeout");
+
+      const catalog = await call({
+        entry: "shop/catalog",
+        path: "/search",
+        method: "GET",
+        persona: "hq-staff",
+        devRegistryError: spec,
+      });
+      expect(catalog.status).toBe(403);
+      expect(await catalog.json()).toEqual({ error: "not_granted" });
+    }
+  });
+
+  it("ignores an unknown code and still applies a global one", async () => {
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    try {
+      const mocked = await call({
+        entry: "shop/catalog",
+        path: "/search",
+        method: "GET",
+        persona: "hq-staff",
+        devRegistryError: "not_a_code",
+      });
+      expect(mocked.status).toBe(200);
+      expect(await mocked.json()).toEqual({ ok: true });
+
+      const forced = await call({
+        entry: "shop/orders",
+        path: "/items/1",
+        method: "GET",
+        persona: "hq-staff",
+        devRegistryError: "shop/orders=not_a_code, needs_beta",
+      });
+      expect(forced.status).toBe(403);
+      expect(forced.headers.get("x-pple-error")).toBe("needs_beta");
+      expect(warn.mock.calls.some((args) => String(args[0]).includes("not_a_code"))).toBe(true);
+    } finally {
+      warn.mockRestore();
+    }
+  });
+
+  it("applies before the missing-token refusal", async () => {
+    const res = await call({
+      entry: "shop/orders",
+      path: "/items/1",
+      method: "GET",
+      persona: "hq-staff",
+      devRegistryError: "not_granted",
+    });
+    expect(res.status).toBe(403);
+    expect(await res.json()).toEqual({ error: "not_granted" });
+  });
+});
+
+function call(input: OverlayCall): Promise<Response> {
+  return Promise.resolve(answerFromOverlay(overlay, input));
+}

package/templates/golden-path/test/dev-read-dataset.test.ts

@@ -0,0 +1,270 @@
+// Offline readDataset (issue #270, ADR-0030). Vitest never lets readDataset
+// read `.pple/`. These tests feed the overlay fixture glob and read the
+// status, headers, and body a Builder would see.
+
+import { beforeAll, describe, expect, it, vi } from "vitest";
+import { platformError } from "../src/call-service";
+import { answerOfflineDataset, type OfflineDatasetCall } from "../src/dev-read-dataset";
+
+const overlay: Record<string, unknown> = import.meta.glob("./fixtures/overlay/**/*", {
+  eager: true,
+  query: "?raw",
+  import: "default",
+});
+
+const writtenAt: Record<string, unknown> = import.meta.glob("./fixtures/overlay/**/*", {
+  eager: true,
+  query: "?mtime",
+  import: "default",
+});
+
+beforeAll(() => {
+  const keys = Object.keys(overlay).join("\n");
+  expect(keys).toContain("directory/branches/entry.md");
+  expect(keys).toContain("directory/branches/mocks/offices.json");
+  expect(keys).toContain("directory/branches/mocks/summary.json");
+  const offices = timeFor("mocks/offices.json");
+  expect(offices).toMatch(/^\d{4}-\d{2}-\d{2}T/);
+});
+
+describe("offline readDataset", () => {
+  it("filters, sorts with id descending on a tie, and pages", async () => {
+    const filtered = await read({
+      objectType: "offices",
+      search: [
+        ["province", "เชียงใหม่"],
+        ["seats[gte]", "4"],
+      ],
+    });
+    expect(filtered.status).toBe(200);
+    expect(filtered.headers.get("x-pple-mock")).toBe("directory/branches");
+    expect(filtered.headers.get("x-pple-error")).toBeNull();
+    expect(platformError(filtered)).toBeNull();
+    const filteredBody = await filtered.json<{ objects: { id: string }[]; next: null; sweptAt: string; snapshot: number }>();
+    expect(filteredBody.objects.map((object) => object.id)).toEqual(["branch-a", "branch-c"]);
+    expect(filteredBody.sweptAt).toBe(timeFor("mocks/offices.json"));
+    expect(filtered.headers.get("etag")).toBe(`"${filteredBody.snapshot}-${etagHash(filtered)}"`);
+
+    const descending = await read({ objectType: "offices", search: [["sort", "-seats"]] });
+    const descendingBody = await descending.json<{ objects: { id: string }[]; snapshot: number; sweptAt: string }>();
+    expect(descendingBody.objects.map((object) => object.id)).toEqual([
+      "branch-b",
+      "branch-c",
+      "branch-a",
+      "branch-d",
+    ]);
+    expect(descendingBody.sweptAt).toBe(filteredBody.sweptAt);
+    expect(descendingBody.snapshot).toBe(filteredBody.snapshot);
+
+    const first = await read({ objectType: "offices", search: [["sort", "seats"], ["limit", "1"]] });
+    const firstBody = await first.json<{ objects: { id: string }[]; next: string | null; sweptAt: string }>();
+    expect(firstBody.objects.map((object) => object.id)).toEqual(["branch-d"]);
+    expect(firstBody.next).toEqual(expect.any(String));
+    expect(firstBody.sweptAt).toBe(timeFor("mocks/offices.json"));
+
+    const second = await read({
+      objectType: "offices",
+      search: [["sort", "seats"], ["limit", "1"], ["next", firstBody.next ?? ""]],
+    });
+    const secondBody = await second.json<{ objects: { id: string }[]; next: string | null; sweptAt: string }>();
+    expect(secondBody.objects.map((object) => object.id)).toEqual(["branch-a"]);
+    expect(secondBody.sweptAt).toBe(firstBody.sweptAt);
+  });
+
+  it("uses the mock file's write time, not entry.md, when both are known", async () => {
+    const res = await read(
+      { objectType: "offices" },
+      {
+        "/virtual/directory/branches/mocks/offices.json": "2024-05-01T00:00:00.000Z",
+        "/virtual/directory/branches/entry.md": "2020-01-01T00:00:00.000Z",
+      },
+    );
+    const body = await res.json<{ sweptAt: string }>();
+    expect(body.sweptAt).toBe("2024-05-01T00:00:00.000Z");
+  });
+
+  it("looks an object up by id, and refuses a query on that lookup or on a singleton", async () => {
+    const found = await read({ objectType: "offices", id: "branch-b" });
+    expect(found.status).toBe(200);
+    expect(await found.json()).toMatchObject({
+      object: { id: "branch-b", province: "กรุงเทพ", seats: 9 },
+      sweptAt: timeFor("mocks/offices.json"),
+    });
+
+    const missing = await read({ objectType: "offices", id: "branch-z" });
+    expect(missing.status).toBe(404);
+    expect(missing.headers.get("x-pple-error")).toBe("not_found");
+    expect(missing.headers.get("x-pple-mock")).toBeNull();
+    expect(platformError(missing)).toBe("not_found");
+
+    const queried = await read({ objectType: "offices", id: "branch-b", search: [["limit", "1"]] });
+    expect(queried.status).toBe(400);
+    expect(queried.headers.get("x-pple-error")).toBe("invalid_query");
+    expect(platformError(queried)).toBe("invalid_query");
+
+    const summary = await read({ objectType: "summary", persona: "member", userToken: undefined });
+    expect(summary.status).toBe(200);
+    expect(summary.headers.get("x-pple-mock")).toBe("directory/branches");
+    expect(await summary.json()).toMatchObject({ object: { title: "สรุปสาขา" } });
+
+    const summaryQuery = await read({ objectType: "summary", search: [["limit", "1"]] });
+    expect(summaryQuery.status).toBe(400);
+    expect(summaryQuery.headers.get("x-pple-error")).toBe("invalid_query");
+
+    const summaryId = await read({ objectType: "summary", id: "1" });
+    expect(summaryId.status).toBe(404);
+    expect(summaryId.headers.get("x-pple-error")).toBe("not_found");
+  });
+
+  it("refuses the member-only persona on an internal type and admits hq-staff", async () => {
+    for (const userToken of [undefined, "", "  "]) {
+      const res = await read({ objectType: "offices", persona: "member", userToken });
+      expect(res.status).toBe(401);
+      expect(res.headers.get("x-pple-error")).toBe("user_token_invalid");
+      expect(platformError(res)).toBe("user_token_invalid");
+      expect(res.headers.get("x-pple-mock")).toBeNull();
+    }
+
+    const member = await read({ objectType: "roster", persona: "member", userToken: "t" });
+    expect(member.status).toBe(403);
+    expect(member.headers.get("x-pple-error")).toBe("level_not_met");
+    expect(member.headers.get("x-pple-mock")).toBeNull();
+    expect(platformError(member)).toBe("level_not_met");
+    expect(await member.json()).toEqual({ error: "level_not_met" });
+
+    const staff = await read({ objectType: "roster", persona: "hq-staff", userToken: "t" });
+    expect(staff.status).toBe(200);
+    expect(await staff.json()).toMatchObject({ objects: [{ id: "r1", province: "เชียงใหม่" }] });
+
+    const memberOffices = await read({ objectType: "offices", persona: "member", userToken: "t" });
+    expect(memberOffices.status).toBe(200);
+    const offices = await memberOffices.json<{ objects: { id: string }[] }>();
+    expect(offices.objects.map((object) => object.id)).toEqual(["branch-a", "branch-b", "branch-c", "branch-d"]);
+  });
+
+  it("fails closed when subs are missing or swept", async () => {
+    const swept = await read({ objectType: "audience", userToken: "t" });
+    expect(swept.status).toBe(403);
+    expect(swept.headers.get("x-pple-error")).toBe("level_not_met");
+
+    const stripped = await read({ objectType: "named", userToken: "t" });
+    expect(stripped.status).toBe(403);
+    expect(stripped.headers.get("x-pple-error")).toBe("level_not_met");
+
+    const memberSwept = await read({ objectType: "audience", persona: "member", userToken: "t" });
+    expect(memberSwept.status).toBe(403);
+    expect(memberSwept.headers.get("x-pple-error")).toBe("level_not_met");
+  });
+
+  it("refuses an invalid query the way production does", async () => {
+    const badValue = await read({ objectType: "offices", search: [["seats", "nope"]] });
+    expect(badValue.status).toBe(400);
+    expect(badValue.headers.get("x-pple-error")).toBe("invalid_query");
+    expect(platformError(badValue)).toBe("invalid_query");
+    expect(badValue.headers.get("x-pple-mock")).toBeNull();
+
+    const badField = await read({ objectType: "offices", search: [["city", "เชียงใหม่"]] });
+    expect(badField.headers.get("x-pple-error")).toBe("invalid_query");
+
+    const badLimit = await read({ objectType: "offices", search: [["limit", "0"]] });
+    expect(badLimit.headers.get("x-pple-error")).toBe("invalid_query");
+  });
+
+  it("says no_mock for a missing entry or mock, and not_found for an unknown type", async () => {
+    const missing = await read({ entry: "directory/missing", objectType: "offices" });
+    expect(missing.status).toBe(404);
+    expect(missing.headers.get("x-pple-error")).toBe("no_mock");
+    expect(missing.headers.get("x-pple-mock")).toBeNull();
+    expect(platformError(missing)).toBeNull();
+    const missingBody = await missing.json<{ error: string; message: string }>();
+    expect(missingBody.error).toBe("no_mock");
+    expect(missingBody.message).toContain("pple registry");
+    expect(missingBody.message).toContain(".pple/registry/");
+    expect(missingBody.message).toMatch(/[\u0E00-\u0E7F]/);
+
+    const gap = await read({ objectType: "gap" });
+    expect(gap.status).toBe(404);
+    expect(gap.headers.get("x-pple-error")).toBe("no_mock");
+    const gapBody = await gap.json<{ error: string; message: string }>();
+    expect(gapBody.message).toContain("pple registry");
+    expect(gapBody.message).toContain("gap");
+
+    const unknown = await read({ objectType: "nope" });
+    expect(unknown.status).toBe(404);
+    expect(unknown.headers.get("x-pple-error")).toBe("not_found");
+    expect(platformError(unknown)).toBe("not_found");
+    expect(unknown.headers.get("x-pple-mock")).toBeNull();
+  });
+});
+
+describe("DEV_REGISTRY_ERROR", () => {
+  it("returns the platform refusal before the token and the level", async () => {
+    const res = await read({
+      objectType: "roster",
+      persona: "member",
+      devRegistryError: "not_granted",
+    });
+    expect(res.status).toBe(403);
+    expect(res.headers.get("x-pple-error")).toBe("not_granted");
+    expect(res.headers.get("x-pple-mock")).toBeNull();
+    expect(platformError(res)).toBe("not_granted");
+    expect(await res.json()).toEqual({ error: "not_granted" });
+  });
+
+  it("lets a per-entry code win, and accepts a dataset refusal code", async () => {
+    const specific = await read({
+      objectType: "offices",
+      devRegistryError: "not_granted, directory/branches=needs_beta",
+    });
+    expect(specific.status).toBe(403);
+    expect(specific.headers.get("x-pple-error")).toBe("needs_beta");
+
+    const other = await read({
+      entry: "shop/orders",
+      objectType: "offices",
+      devRegistryError: "not_granted, directory/branches=needs_beta",
+    });
+    expect(other.headers.get("x-pple-error")).toBe("not_granted");
+
+    const level = await read({ objectType: "offices", devRegistryError: "level_not_met" });
+    expect(level.status).toBe(403);
+    expect(level.headers.get("x-pple-error")).toBe("level_not_met");
+
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    try {
+      const ignored = await read({
+        objectType: "summary",
+        devRegistryError: "directory/branches=not_a_code, not_listed",
+      });
+      expect(ignored.status).toBe(404);
+      expect(ignored.headers.get("x-pple-error")).toBe("not_listed");
+    } finally {
+      warn.mockRestore();
+    }
+  });
+});
+
+function timeFor(suffix: string): string {
+  const key = Object.keys(writtenAt).find((file) => file.includes(suffix));
+  const value = key ? writtenAt[key] : undefined;
+  if (typeof value !== "string") throw new Error(`no mtime for ${suffix}`);
+  return value;
+}
+
+function etagHash(response: Response): string {
+  const tag = response.headers.get("etag") ?? "";
+  const hash = tag.replaceAll('"', "").split("-")[1];
+  return hash ?? "";
+}
+
+function read(
+  input: Partial<OfflineDatasetCall> & { objectType: string },
+  times: Record<string, unknown> = writtenAt,
+): Promise<Response> {
+  return Promise.resolve(answerOfflineDataset(overlay, times, {
+    entry: "directory/branches",
+    persona: "hq-staff",
+    userToken: "t",
+    ...input,
+  }));
+}