@pplethai/cli 0.7.0 → 0.8.0

package/templates/golden-path/test/dev-registry.test.ts

@@ -0,0 +1,375 @@
+// Offline Provider development (ADR-0026). What the handler observes:
+// serviceCall, the tail path, and the status. The dev wrapper is the Worker
+// entry under vitest, where import.meta.env.DEV is true.
+
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { DEV_PERSONAS } from "../src/dev-personas";
+import { devWorkerFetch } from "../src/dev-registry";
+import worker from "../src/index";
+import { serviceCall } from "../src/registry";
+import { makeHarness, testExecutionContext } from "./harness";
+
+const ctx = testExecutionContext();
+
+afterEach(() => {
+  const registry = worker.registry ?? {};
+  for (const key of Object.keys(registry)) delete registry[key];
+});
+
+function install(name: string): { request?: Request } {
+  const seen: { request?: Request } = {};
+  if (!worker.registry) throw new Error("worker has no registry");
+  worker.registry[name] = (request) => {
+    seen.request = request;
+    const url = new URL(request.url);
+    return Response.json({
+      call: serviceCall(request),
+      path: url.pathname,
+      search: url.search,
+      method: request.method,
+      authorization: request.headers.get("authorization"),
+      secret: request.headers.get("x-pple-cron-secret"),
+    });
+  };
+  return seen;
+}
+
+describe("the emulated registry path", () => {
+  it("delivers the tail to the handler with the default Persona and dev-consumer", async () => {
+    install("branch-list");
+    const h = makeHarness();
+
+    const res = await worker.fetch(
+      new Request("https://localhost/.pple/registry/branch-list/offices?q=1"),
+      h.testEnv,
+      ctx,
+    );
+
+    expect(res.status).toBe(200);
+    expect(await res.json()).toEqual({
+      call: {
+        consumer: "dev-consumer",
+        entry: "dev-provider/branch-list",
+        identity: DEV_PERSONAS["hq-staff"],
+      },
+      path: "/offices",
+      search: "?q=1",
+      method: "GET",
+      authorization: null,
+      secret: null,
+    });
+  });
+
+  it("uses DEV_PERSONA and DEV_CONSUMER, and ignores forged platform headers", async () => {
+    install("branch-list");
+    const h = makeHarness({}, { DEV_PERSONA: "province-coordinator", DEV_CONSUMER: "brave-purple-lion" });
+
+    const res = await worker.fetch(
+      new Request("https://localhost/.pple/registry/branch-list", {
+        headers: {
+          "x-pple-consumer": "forged",
+          "x-pple-entry": "forged/nope",
+          "x-pple-identity": "forged",
+          authorization: "Bearer raw-token",
+          "x-pple-cron-secret": "s3cret",
+        },
+      }),
+      h.testEnv,
+      ctx,
+    );
+
+    expect(await res.json()).toMatchObject({
+      call: {
+        consumer: "brave-purple-lion",
+        entry: "dev-provider/branch-list",
+        identity: DEV_PERSONAS["province-coordinator"],
+      },
+      path: "/",
+      authorization: null,
+      secret: null,
+    });
+  });
+
+  it("sends no Identity when DEV_PERSONA is none", async () => {
+    install("branch-list");
+    const h = makeHarness({}, { DEV_PERSONA: "none" });
+
+    const res = await worker.fetch(
+      new Request("https://localhost/.pple/registry/branch-list/offices"),
+      h.testEnv,
+      ctx,
+    );
+
+    expect(await res.json()).toMatchObject({
+      call: { consumer: "dev-consumer", entry: "dev-provider/branch-list", identity: null },
+      path: "/offices",
+    });
+  });
+
+  it("sends no Identity when the Persona name does not exist", async () => {
+    install("branch-list");
+    const h = makeHarness({}, { DEV_PERSONA: "not-a-persona" });
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    try {
+      const res = await worker.fetch(
+        new Request("https://localhost/.pple/registry/branch-list/"),
+        h.testEnv,
+        ctx,
+      );
+
+      expect(await res.json()).toMatchObject({
+        call: { consumer: "dev-consumer", identity: null },
+        path: "/",
+      });
+      expect(warn).toHaveBeenCalled();
+    } finally {
+      warn.mockRestore();
+    }
+  });
+
+  it("passes the method and body through, and a non-fetch value throws", async () => {
+    const seen: { body?: string; type?: string | null; connection?: string | null } = {};
+    if (!worker.registry) throw new Error("worker has no registry");
+    worker.registry["branch-list"] = async (request) => {
+      seen.body = await request.text();
+      seen.type = request.headers.get("content-type");
+      seen.connection = request.headers.get("connection");
+      return new Response("created", { status: 201, headers: { "x-pple-extra": "kept-here" } });
+    };
+    const h = makeHarness();
+
+    const res = await worker.fetch(
+      new Request("https://localhost/.pple/registry/branch-list/items", {
+        method: "POST",
+        headers: { "content-type": "text/plain", connection: "close" },
+        body: "เนื้อหา",
+      }),
+      h.testEnv,
+      ctx,
+    );
+
+    expect(res.status).toBe(201);
+    expect(await res.text()).toBe("created");
+    expect(res.headers.get("x-pple-extra")).toBe("kept-here");
+    expect(seen).toEqual({ body: "เนื้อหา", type: "text/plain", connection: null });
+
+    Object.assign(worker.registry, { "branch-list": { pages: () => ({}) } });
+    await expect(
+      worker.fetch(new Request("https://localhost/.pple/registry/branch-list"), h.testEnv, ctx),
+    ).rejects.toThrow("registry handler missing");
+  });
+
+  it("calls a Dataset page function with the cursor and answers with the page", async () => {
+    if (!worker.registry) throw new Error("worker has no registry");
+    let cursor: string | null = "unset";
+    worker.registry["branch-list"] = {
+      offices: (input) => {
+        cursor = input.cursor;
+        return { objects: [{ id: "a", name: "สาขา" }], next: null };
+      },
+    };
+    const h = makeHarness();
+
+    const res = await worker.fetch(
+      new Request("https://localhost/.pple/registry/branch-list/offices", {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ cursor: "a" }),
+      }),
+      h.testEnv,
+      ctx,
+    );
+
+    expect(res.status).toBe(200);
+    expect(await res.json()).toEqual({ objects: [{ id: "a", name: "สาขา" }], next: null });
+    expect(cursor).toBe("a");
+  });
+
+  it("calls a fetch-shaped object with itself as this", async () => {
+    const app = {
+      marker: "hono",
+      fetch(this: { marker: string }, request: Request) {
+        return Response.json({ self: this.marker, path: new URL(request.url).pathname });
+      },
+    };
+    if (!worker.registry) throw new Error("worker has no registry");
+    worker.registry["branch-list"] = app;
+    const h = makeHarness();
+
+    const res = await worker.fetch(
+      new Request("https://localhost/.pple/registry/branch-list/offices"),
+      h.testEnv,
+      ctx,
+    );
+
+    expect(await res.json()).toEqual({ self: "hono", path: "/offices" });
+  });
+
+  it("answers 404 when the registry path names no entry", async () => {
+    const h = makeHarness();
+    const res = await worker.fetch(new Request("https://localhost/.pple/registry/"), h.testEnv, ctx);
+    expect(res.status).toBe(404);
+    expect(res.headers.get("cache-control")).toBe("no-store");
+  });
+});
+
+describe("public traffic under dev", () => {
+  it("strips x-pple-* before app code and still serves the route", async () => {
+    let ran = false;
+    if (!worker.registry) throw new Error("worker has no registry");
+    worker.registry["branch-list"] = () => {
+      ran = true;
+      return new Response("no");
+    };
+    const h = makeHarness();
+
+    const res = await worker.fetch(
+      new Request("https://localhost/api/health", {
+        headers: {
+          "x-pple-consumer": "forged",
+          "x-pple-entry": "forged/branch-list",
+          "x-pple-identity": "forged",
+        },
+      }),
+      h.testEnv,
+      ctx,
+    );
+
+    expect(res.status).toBe(200);
+    expect(await res.json()).toEqual({ ok: true });
+    expect(ran).toBe(false);
+
+    let seen: Request | undefined;
+    const stripped = await devWorkerFetch(
+      {
+        fetch(request) {
+          seen = request;
+          return new Response("app");
+        },
+        registry: {},
+      },
+      new Request("https://localhost/api/notes", {
+        headers: {
+          authorization: "Bearer keep",
+          cookie: "session=keep",
+          "x-request-id": "keep",
+          "x-pple-consumer": "forged",
+          "x-pple-identity": "forged",
+          "X-Pple-User-Token": "raw-token",
+        },
+      }),
+      h.testEnv,
+      ctx,
+    );
+
+    expect(stripped.status).toBe(200);
+    if (!seen) throw new Error("public request did not reach app code");
+    expect(serviceCall(seen)).toBeNull();
+    expect(seen.headers.get("authorization")).toBe("Bearer keep");
+    expect(seen.headers.get("cookie")).toBe("session=keep");
+    expect(seen.headers.get("x-request-id")).toBe("keep");
+    expect(seen.headers.get("x-pple-consumer")).toBeNull();
+    expect(seen.headers.get("x-pple-user-token")).toBeNull();
+  });
+});
+
+describe("callRegistry", () => {
+  it("calls the handler with the Persona and Consumer overrides", async () => {
+    const seen: { request?: Request } = {};
+    if (!worker.registry) throw new Error("worker has no registry");
+    worker.registry["branch-list"] = (request) => {
+      seen.request = request;
+      return Response.json(serviceCall(request));
+    };
+    const h = makeHarness({}, { DEV_PERSONA: "delegate", DEV_CONSUMER: "from-env" });
+
+    const res = await h.callRegistry("branch-list", "/offices?q=1", {
+      persona: "province-coordinator",
+      consumer: "brave-purple-lion",
+    });
+
+    expect(res.status).toBe(200);
+    expect(await res.json()).toEqual({
+      consumer: "brave-purple-lion",
+      entry: "dev-provider/branch-list",
+      identity: DEV_PERSONAS["province-coordinator"],
+    });
+    if (!seen.request) throw new Error("handler did not run");
+    const url = new URL(seen.request.url);
+    expect(url.pathname).toBe("/offices");
+    expect(url.search).toBe("?q=1");
+  });
+
+  it("preserves the method and body, and drops a forged platform header", async () => {
+    if (!worker.registry) throw new Error("worker has no registry");
+    worker.registry["branch-list"] = async (request) =>
+      Response.json({
+        call: serviceCall(request),
+        method: request.method,
+        type: request.headers.get("content-type"),
+        authorization: request.headers.get("authorization"),
+        body: await request.text(),
+      });
+    const h = makeHarness();
+
+    const res = await h.callRegistry("branch-list", "/items", {
+      persona: "none",
+      consumer: "brave-purple-lion",
+      init: {
+        method: "POST",
+        headers: {
+          "content-type": "text/plain",
+          "x-pple-consumer": "forged",
+          authorization: "Bearer raw-token",
+        },
+        body: "เนื้อหา",
+      },
+    });
+
+    expect(await res.json()).toEqual({
+      call: {
+        consumer: "brave-purple-lion",
+        entry: "dev-provider/branch-list",
+        identity: null,
+      },
+      method: "POST",
+      type: "text/plain",
+      authorization: null,
+      body: "เนื้อหา",
+    });
+  });
+
+  it("uses the harness Persona and Consumer when no override is passed", async () => {
+    if (!worker.registry) throw new Error("worker has no registry");
+    let path = "";
+    worker.registry["branch-list"] = (request) => {
+      path = new URL(request.url).pathname;
+      return Response.json(serviceCall(request));
+    };
+    const h = makeHarness({}, { DEV_PERSONA: "delegate", DEV_CONSUMER: "from-env" });
+
+    const res = await h.callRegistry("branch-list", "items");
+
+    expect(await res.json()).toEqual({
+      consumer: "from-env",
+      entry: "dev-provider/branch-list",
+      identity: DEV_PERSONAS.delegate,
+    });
+    expect(path).toBe("/items");
+  });
+
+  it("sends no Identity for persona none, and throws when the entry has no handler", async () => {
+    if (!worker.registry) throw new Error("worker has no registry");
+    worker.registry["branch-list"] = (request) => Response.json(serviceCall(request));
+    const h = makeHarness({}, { DEV_PERSONA: "hq-staff" });
+
+    const res = await h.callRegistry("branch-list", "/", { persona: "none" });
+    expect(await res.json()).toMatchObject({ consumer: "dev-consumer", identity: null });
+
+    delete worker.registry["branch-list"];
+    // The platform wrapper throws this. pple-services answers provider_unavailable
+    // (502) to the Consumer. callRegistry throws the same error and does not
+    // invent that response.
+    await expect(h.callRegistry("branch-list", "/offices")).rejects.toThrow("registry handler missing");
+  });
+});

package/templates/golden-path/test/effective-sub.test.ts

@@ -0,0 +1,101 @@
+// effective.sub (ADR-0028): userinfo onto /api/me, then the same passesLevel
+// a Dataset read will use. The read API does not exist yet.
+
+import { describe, expect, it } from "vitest";
+import { passesLevel, type LevelIdentity } from "../src/levels";
+import { makeHarness } from "./harness";
+
+const SUPERVISOR = "347513243977122153";
+const LEGACY = "11111111-2222-3333-4444-555555555555";
+
+function signedIn(ad: Record<string, unknown>, sub = "u-actor") {
+  return makeHarness(
+    {
+      sso: () => Response.json({ sub, name: "Nok", ad }),
+    },
+    { DEV_PERSONA: "none" },
+  );
+}
+
+async function me(ad: Record<string, unknown>, sub = "u-actor"): Promise<LevelIdentity> {
+  const res = await signedIn(ad, sub).request("/api/me", {}, "valid-token");
+  expect(res.status).toBe(200);
+  return res.json<LevelIdentity>();
+}
+
+describe("effective.sub", () => {
+  it("is the actor sub when nobody is delegating, even if ad.user carries a Zitadel id", async () => {
+    const identity = await me(
+      {
+        user: { id: 7, role: "hq", zitadel_user_id: SUPERVISOR, sso_user_id: LEGACY },
+        actualPpleUser: { id: 7, role: "hq" },
+      },
+      "u-42",
+    );
+    expect(identity.effective.isDelegated).toBe(false);
+    expect(identity.effective.sub).toBe("u-42");
+    expect(JSON.stringify(identity)).not.toContain(SUPERVISOR);
+    expect(JSON.stringify(identity)).not.toContain(LEGACY);
+    expect(passesLevel(identity, { subs: ["u-42"] })).toBe(true);
+    expect(passesLevel(identity, { subs: [SUPERVISOR] })).toBe(false);
+  });
+
+  it("is the supervisor's zitadel id under delegation, and that passes their subs level", async () => {
+    const identity = await me({
+      user: { id: 9, role: "province", zitadel_user_id: SUPERVISOR, sso_user_id: LEGACY },
+      actualPpleUser: { id: 14, role: "delegate" },
+      activeRole: "province",
+    });
+    expect(identity.effective.isDelegated).toBe(true);
+    expect(identity.actor.sub).toBe("u-actor");
+    expect(identity.effective.sub).toBe(SUPERVISOR);
+    expect(JSON.stringify(identity)).not.toContain(LEGACY);
+    expect(passesLevel(identity, { subs: [SUPERVISOR] })).toBe(true);
+    expect(passesLevel(identity, { subs: ["u-actor"] })).toBe(true);
+    expect(passesLevel(identity, { subs: [LEGACY] })).toBe(false);
+  });
+
+  it.each([
+    ["null", { zitadel_user_id: null }],
+    ["only sso_user_id", {}],
+    ["a uuid", { zitadel_user_id: LEGACY }],
+    ["a number", { zitadel_user_id: 347513243977122153 }],
+  ] as const)(
+    "is null when the supervisor zitadel id is %s, and that passes no named subs level",
+    async (_label, extra) => {
+      const identity = await me({
+        user: { id: 9, role: "province", sso_user_id: LEGACY, ...extra },
+        actualPpleUser: { id: 14, role: "delegate" },
+      });
+      expect(identity.effective.sub).toBeNull();
+      expect(JSON.stringify(identity)).not.toContain(LEGACY);
+      expect(passesLevel(identity, { subs: [SUPERVISOR] })).toBe(false);
+      expect(passesLevel(identity, { subs: [LEGACY] })).toBe(false);
+      expect(passesLevel(identity, { subs: ["u-actor"] })).toBe(true);
+    },
+  );
+
+  it("does not treat ad.user as a supervisor unless the logged-in role is delegate and the rows differ", async () => {
+    const samePerson = await me(
+      {
+        user: { id: 14, role: "delegate", zitadel_user_id: SUPERVISOR },
+        actualPpleUser: { id: 14, role: "delegate" },
+      },
+      "u-actor",
+    );
+    expect(samePerson.effective.isDelegated).toBe(false);
+    expect(samePerson.effective.sub).toBe("u-actor");
+
+    const notADelegate = await me(
+      {
+        user: { id: 9, role: "province", zitadel_user_id: SUPERVISOR },
+        actualPpleUser: { id: 14, role: "hq" },
+      },
+      "u-actor",
+    );
+    // Delegated rows, but not a recognised delegate: never the actor's own sub.
+    expect(notADelegate.effective.isDelegated).toBe(true);
+    expect(notADelegate.effective.sub).toBeNull();
+    expect(passesLevel(notADelegate, { subs: [SUPERVISOR] })).toBe(false);
+  });
+});

package/templates/golden-path/test/fixtures/overlay/directory/branches/entry.md

@@ -0,0 +1,85 @@
+---
+kind: dataset
+visibility: private
+description: สาขาสำหรับทดสอบ
+level: public
+objectTypes:
+  offices:
+    shape: collection
+    cadence: 1d
+    id: id
+    index:
+      - province
+      - seats
+    level: member
+    schema:
+      type: object
+      properties:
+        id:
+          type: string
+        province:
+          type: string
+        seats:
+          type: integer
+          minimum: 0
+      required:
+        - id
+  roster:
+    shape: collection
+    cadence: 1d
+    id: id
+    index:
+      - province
+    level: internal
+    schema:
+      type: object
+      properties:
+        id:
+          type: string
+        province:
+          type: string
+  summary:
+    shape: singleton
+    cadence: 1d
+    schema:
+      type: object
+      properties:
+        title:
+          type: string
+  audience:
+    shape: collection
+    cadence: 1d
+    id: id
+    index: []
+    level:
+      subs: swept
+    schema:
+      type: object
+      properties:
+        id:
+          type: string
+  named:
+    shape: collection
+    cadence: 1d
+    id: id
+    index: []
+    level: {}
+    schema:
+      type: object
+      properties:
+        id:
+          type: string
+  gap:
+    shape: collection
+    cadence: 1d
+    id: id
+    index: []
+    level: public
+    schema:
+      type: object
+      properties:
+        id:
+          type: string
+---
+
+สาขาสำหรับทดสอบออฟไลน์

package/templates/golden-path/test/fixtures/overlay/directory/branches/mocks/audience.json

@@ -0,0 +1,3 @@
+[
+  { "id": "a1" }
+]

package/templates/golden-path/test/fixtures/overlay/directory/branches/mocks/named.json

@@ -0,0 +1,3 @@
+[
+  { "id": "n1" }
+]

package/templates/golden-path/test/fixtures/overlay/directory/branches/mocks/offices.json

@@ -0,0 +1,6 @@
+[
+  { "id": "branch-a", "province": "เชียงใหม่", "seats": 4 },
+  { "id": "branch-b", "province": "กรุงเทพ", "seats": 9 },
+  { "id": "branch-c", "province": "เชียงใหม่", "seats": 4 },
+  { "id": "branch-d", "province": "เชียงใหม่", "seats": 1 }
+]

package/templates/golden-path/test/fixtures/overlay/directory/branches/mocks/roster.json

@@ -0,0 +1,3 @@
+[
+  { "id": "r1", "province": "เชียงใหม่" }
+]

package/templates/golden-path/test/fixtures/overlay/directory/branches/mocks/summary.json

@@ -0,0 +1 @@
+{ "title": "สรุปสาขา" }

package/templates/golden-path/test/fixtures/overlay/platform/legal-identity/entry.md

@@ -0,0 +1,8 @@
+---
+kind: service
+visibility: private
+userToken: required
+description: อ่านชื่อสำหรับทดสอบ
+---
+
+# Legal Identity

package/templates/golden-path/test/fixtures/overlay/platform/legal-identity/mocks/responses.json

@@ -0,0 +1,13 @@
+[
+  {
+    "method": "POST",
+    "path": "/",
+    "persona": "hq-staff",
+    "body": { "source": "membership" }
+  },
+  {
+    "method": "POST",
+    "path": "/",
+    "body": { "source": "default" }
+  }
+]

package/templates/golden-path/test/fixtures/overlay/shop/catalog/entry.md

@@ -0,0 +1,8 @@
+---
+kind: service
+visibility: public
+userToken: none
+description: แคตตาล็อกสำหรับทดสอบ
+---
+
+# Catalog

package/templates/golden-path/test/fixtures/overlay/shop/catalog/mocks/responses.json

@@ -0,0 +1,7 @@
+[
+  {
+    "method": "GET",
+    "path": "/search",
+    "body": { "ok": true }
+  }
+]

package/templates/golden-path/test/fixtures/overlay/shop/orders/entry.md

@@ -0,0 +1,12 @@
+---
+kind: service
+visibility: private
+userToken: required
+description: รายการสั่งซื้อสำหรับทดสอบ
+---
+
+# Orders
+
+GET /items/:id
+POST /
+GET /files/*

package/templates/golden-path/test/fixtures/overlay/shop/orders/mocks/responses.json

@@ -0,0 +1,36 @@
+[
+  {
+    "method": "GET",
+    "path": "/items/:id",
+    "persona": "hq-staff",
+    "status": 200,
+    "headers": { "x-shop": "hq", "x-pple-error": "forged" },
+    "body": { "item": "hq" }
+  },
+  {
+    "method": "GET",
+    "path": "/items/:id",
+    "persona": ["delegate", "platform-admin"],
+    "body": { "item": "listed" }
+  },
+  {
+    "method": "GET",
+    "path": "/items/:id",
+    "body": { "item": "open" }
+  },
+  {
+    "method": "get",
+    "path": "/items/:id",
+    "body": { "item": "later" }
+  },
+  {
+    "method": "POST",
+    "path": "/",
+    "status": 201,
+    "body": { "created": true }
+  },
+  {
+    "path": "/files/*",
+    "body": "listed"
+  }
+]