@supersoniks/concorde 4.9.91 → 4.9.93

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@supersoniks/concorde",
-  "version": "4.9.91",
+  "version": "4.9.93",
   "license": "MIT",
   "type": "module",
   "main": "",

package/src/core/decorators/api.post.spec.ts

@@ -95,14 +95,14 @@ describe("post", () => {
     vi.mocked(API.prototype.postDetailed).mockClear();
 
     pub.set({ value: "second" });
-    localPost.send(el);
-    await flushSendFrames();
+    const payload = await localPost.send(el);
 
     expect(API.prototype.postDetailed).toHaveBeenCalledTimes(1);
     expect(API.prototype.postDetailed).toHaveBeenCalledWith(
       "items/local-send",
       { value: "second" },
     );
+    expect(payload?.result).toEqual({ ok: true });
   });
 
   it("peut décorer une méthode avec send après sa résolution", async () => {
@@ -303,6 +303,91 @@ describe("post", () => {
     );
     expect(el.payload?.result).toEqual({ ok: true });
   });
+
+  it("transmet le payload complet et conserve le retrigger du POST", async () => {
+    const bodyPubId = "postSpecHandlerBody";
+    const triggerPubId = "postSpecHandlerTrigger";
+    PublisherManager.get(bodyPubId).set({ tick: 1 });
+    const bodyKey = new DataProviderKey<{ tick: number }>(bodyPubId);
+    const triggerKey = new DataProviderKey<number>(triggerPubId);
+    const ep = new Endpoint<{ ok: boolean }>("items/handler");
+    const localPost = post(ep, bodyKey, {
+      autoPostOnBodyMutation: false,
+      triggerKey,
+    });
+    const received: Array<ApiResult<{ ok: boolean }> | undefined> = [];
+    const errorPayload = mockPayload({ ok: false });
+    errorPayload.response = new Response(JSON.stringify({ error: true }), {
+      status: 409,
+      headers: { "Content-Type": "application/json" },
+    });
+    vi.mocked(API.prototype.postDetailed).mockResolvedValueOnce(
+      errorPayload as never,
+    );
+    const tag = "test-api-post-handler";
+
+    class C extends HTMLElement {
+      @localPost
+      onPayload(payload: ApiResult<{ ok: boolean }> | undefined) {
+        received.push(payload);
+      }
+    }
+    if (!customElements.get(tag)) {
+      customElements.define(tag, C);
+    }
+
+    const wrap = document.createElement("div");
+    wrap.setAttribute("serviceURL", "https://api.example.test");
+    const el = document.createElement(tag) as InstanceType<typeof C>;
+    wrap.appendChild(el);
+    document.body.appendChild(wrap);
+    await flushSendFrames();
+
+    expect(API.prototype.postDetailed).not.toHaveBeenCalled();
+    await localPost.send(el);
+    expect(received).toHaveLength(1);
+    expect(received[0]?.response?.status).toBe(409);
+
+    PublisherManager.get(triggerPubId).invalidate();
+    await flushSendFrames();
+    expect(API.prototype.postDetailed).toHaveBeenCalledTimes(2);
+    expect(received).toHaveLength(2);
+  });
+
+  it("transmet undefined à une méthode @post sur une erreur de transport", async () => {
+    const bodyPubId = "postSpecHandlerTransportBody";
+    PublisherManager.get(bodyPubId).set({ tick: 1 });
+    const bodyKey = new DataProviderKey<{ tick: number }>(bodyPubId);
+    const ep = new Endpoint<{ ok: boolean }>("items/handler-transport");
+    const localPost = post(ep, bodyKey, {
+      autoPostOnBodyMutation: false,
+    });
+    const received: Array<ApiResult<{ ok: boolean }> | undefined> = [];
+    vi.mocked(API.prototype.postDetailed).mockRejectedValueOnce(
+      new Error("network failure"),
+    );
+    const tag = "test-api-post-handler-transport";
+
+    class C extends HTMLElement {
+      @localPost
+      onPayload(payload: ApiResult<{ ok: boolean }> | undefined) {
+        received.push(payload);
+      }
+    }
+    if (!customElements.get(tag)) {
+      customElements.define(tag, C);
+    }
+
+    const wrap = document.createElement("div");
+    wrap.setAttribute("serviceURL", "https://api.example.test");
+    const el = document.createElement(tag) as InstanceType<typeof C>;
+    wrap.appendChild(el);
+    document.body.appendChild(wrap);
+    await flushSendFrames();
+
+    await expect(localPost.send(el)).rejects.toThrow("network failure");
+    expect(received).toEqual([undefined]);
+  });
 });
 
 describe("put / patch", () => {
@@ -319,11 +404,15 @@ describe("put / patch", () => {
     PublisherManager.get(bodyPubId).set({ name: "x" });
     const bodyKey = new DataProviderKey<{ name: string }>(bodyPubId);
     const ep = new Endpoint<{ ok: boolean }>("items/1");
+    const localPut = put(ep, bodyKey);
+    const received: Array<ApiResult<{ ok: boolean }> | undefined> = [];
     const tag = "test-api-put";
 
     class C extends HTMLElement {
-      @put(ep, bodyKey)
-      payload: ApiResult<{ ok: boolean }> | null = null;
+      @localPut
+      onPayload(payload: ApiResult<{ ok: boolean }> | undefined) {
+        received.push(payload);
+      }
     }
     if (!customElements.get(tag)) {
       customElements.define(tag, C);
@@ -338,6 +427,7 @@ describe("put / patch", () => {
     expect(API.prototype.putDetailed).toHaveBeenCalledWith("items/1", {
       name: "x",
     });
+    expect(received).toHaveLength(1);
   });
 
   it("@patch appelle patchDetailed", async () => {
@@ -348,11 +438,15 @@ describe("put / patch", () => {
     PublisherManager.get(bodyPubId).set({ name: "y" });
     const bodyKey = new DataProviderKey<{ name: string }>(bodyPubId);
     const ep = new Endpoint<{ ok: boolean }>("items/1");
+    const localPatch = patch(ep, bodyKey);
+    const received: Array<ApiResult<{ ok: boolean }> | undefined> = [];
     const tag = "test-api-patch";
 
     class C extends HTMLElement {
-      @patch(ep, bodyKey)
-      payload: ApiResult<{ ok: boolean }> | null = null;
+      @localPatch
+      onPayload(payload: ApiResult<{ ok: boolean }> | undefined) {
+        received.push(payload);
+      }
     }
     if (!customElements.get(tag)) {
       customElements.define(tag, C);
@@ -367,5 +461,6 @@ describe("put / patch", () => {
     expect(API.prototype.patchDetailed).toHaveBeenCalledWith("items/1", {
       name: "y",
     });
+    expect(received).toHaveLength(1);
   });
 });

package/src/core/decorators/api.spec.ts

@@ -190,6 +190,96 @@ describe("get", () => {
     expect(el.payload?.result).toEqual({ id: "loaded" });
   });
 
+  it("transmet le payload complet à une méthode @get", async () => {
+    const itemEp = new Endpoint<{ id: string }>("items/handler");
+    const received: Array<ApiResult<{ id: string }> | undefined> = [];
+    const tag = "test-api-get-handler";
+    const errorPayload = mockPayload({ id: "error" });
+    errorPayload.response = new Response(JSON.stringify({ error: true }), {
+      status: 422,
+      headers: { "Content-Type": "application/json" },
+    });
+    vi.mocked(API.prototype.getDetailed).mockResolvedValueOnce(
+      errorPayload as never,
+    );
+
+    class C extends HTMLElement {
+      @get(itemEp)
+      onPayload(payload: ApiResult<{ id: string }> | undefined) {
+        received.push(payload);
+      }
+    }
+    if (!customElements.get(tag)) {
+      customElements.define(tag, C);
+    }
+
+    const wrap = document.createElement("div");
+    wrap.setAttribute("serviceURL", "https://api.example.test");
+    wrap.appendChild(document.createElement(tag));
+    document.body.appendChild(wrap);
+    await flushGetFrames();
+
+    expect(received).toHaveLength(1);
+    expect(received[0]?.result).toEqual({ id: "error" });
+    expect(received[0]?.response?.status).toBe(422);
+    expect(received[0]?.request.url).toContain("api.example.test");
+  });
+
+  it("transmet undefined à une méthode @get quand aucun payload n'est produit", async () => {
+    vi.mocked(API.prototype.getDetailed).mockResolvedValueOnce(undefined);
+    const itemEp = new Endpoint<{ id: string }>("items/handler-error");
+    const received: Array<ApiResult<{ id: string }> | undefined> = [];
+    const tag = "test-api-get-handler-undefined";
+
+    class C extends HTMLElement {
+      @get(itemEp)
+      onPayload(payload: ApiResult<{ id: string }> | undefined) {
+        received.push(payload);
+      }
+    }
+    if (!customElements.get(tag)) {
+      customElements.define(tag, C);
+    }
+
+    const wrap = document.createElement("div");
+    wrap.setAttribute("serviceURL", "https://api.example.test");
+    wrap.appendChild(document.createElement(tag));
+    document.body.appendChild(wrap);
+    await flushGetFrames();
+
+    expect(received).toEqual([undefined]);
+  });
+
+  it("permet d'appliquer un handle get directement à une méthode", async () => {
+    const itemEp = new Endpoint<{ id: string }>("items/method");
+    const localGet = get(itemEp);
+    const received: Array<ApiResult<{ id: string }> | undefined> = [];
+    const tag = "test-api-get-method-handler";
+
+    class C extends HTMLElement {
+      @localGet
+      onPayload(payload: ApiResult<{ id: string }> | undefined) {
+        received.push(payload);
+      }
+    }
+    if (!customElements.get(tag)) {
+      customElements.define(tag, C);
+    }
+
+    const wrap = document.createElement("div");
+    wrap.setAttribute("serviceURL", "https://api.example.test");
+    const el = document.createElement(tag) as InstanceType<typeof C>;
+    wrap.appendChild(el);
+    document.body.appendChild(wrap);
+    await flushGetFrames();
+
+    expect(received).toHaveLength(1);
+    expect(received[0]?.result).toEqual({ id: "loaded" });
+
+    await localGet.refetch(el);
+    expect(received).toHaveLength(2);
+  });
+
   it("expose un refetch local avant et après le premier payload", async () => {
     const pubId = "getSpecLocalRefetch";
     PublisherManager.get(pubId).set(staticConfig);
@@ -209,16 +299,18 @@ describe("get", () => {
     const el = document.createElement(tag) as InstanceType<typeof C>;
     document.body.appendChild(el);
 
-    localGet.refetch(el);
-    await flushGetFrames();
+    const firstRefetch = localGet.refetch(el);
+    expect(firstRefetch).toBeInstanceOf(Promise);
+    const firstPayload = await firstRefetch;
     expect(API.prototype.getDetailed).toHaveBeenCalledTimes(1);
+    expect(firstPayload?.result).toEqual({ id: "loaded" });
 
     vi.mocked(API.prototype.getDetailed).mockClear();
     el.payload = mockPayload({ id: "manual" });
-    localGet.refetch(el);
-    await flushGetFrames();
+    const secondPayload = await localGet.refetch(el);
 
     expect(API.prototype.getDetailed).toHaveBeenCalledTimes(1);
+    expect(secondPayload?.result).toEqual({ id: "loaded" });
     expect(el.payload?.result).toEqual({ id: "loaded" });
   });
 
@@ -246,8 +338,7 @@ describe("get", () => {
     vi.mocked(API.prototype.getDetailed).mockClear();
 
     el.remove();
-    localGet.refetch(el);
-    await flushGetFrames();
+    await localGet.refetch(el);
 
     expect(API.prototype.getDetailed).not.toHaveBeenCalled();
   });
@@ -289,6 +380,46 @@ describe("get", () => {
     expect(API.prototype.getDetailed).toHaveBeenCalledWith("rows/84");
   });
 
+  it("attend le refetch avant la méthode avec when before", async () => {
+    const pubId = "getSpecMethodRefetchBefore";
+    PublisherManager.get(pubId).set(staticConfig);
+    const confKey = new DataProviderKey<APIConfiguration>(pubId);
+    const localGet = get(
+      new Endpoint<{ id: string }>("items/before"),
+      confKey,
+    );
+    const events: string[] = [];
+    const tag = "test-api-get-method-refetch-before";
+
+    class C extends HTMLElement {
+      @localGet
+      payload: ApiResult<{ id: string }> | null = null;
+
+      @refetch(localGet, { when: "before" })
+      reload() {
+        events.push("method");
+      }
+    }
+    if (!customElements.get(tag)) {
+      customElements.define(tag, C);
+    }
+
+    const el = document.createElement(tag) as InstanceType<typeof C>;
+    document.body.appendChild(el);
+    await flushGetFrames();
+    vi.mocked(API.prototype.getDetailed).mockClear();
+    events.length = 0;
+    vi.mocked(API.prototype.getDetailed).mockImplementation(async () => {
+      events.push("request");
+      return mockPayload({ id: "loaded" }) as never;
+    });
+
+    await el.reload();
+
+    expect(events).toEqual(["request", "method"]);
+    expect(API.prototype.getDetailed).toHaveBeenCalledWith("items/before");
+  });
+
   it("refetch automatique avec refetchEveryMs", async () => {
     vi.useFakeTimers();
     const itemEp = new Endpoint<{ id: string }>("items/1");