@supersoniks/concorde 4.9.9 → 4.9.92

package/package.json

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

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

@@ -5,7 +5,7 @@ import API, {
   type ApiResult,
 } from "@supersoniks/concorde/core/utils/api";
 import { PublisherManager } from "@supersoniks/concorde/core/utils/PublisherProxy";
-import { patch, post, put } from "./api";
+import { patch, post, put, send } from "./api";
 
 async function flushSendFrames() {
   await new Promise<void>((resolve) => {
@@ -68,6 +68,84 @@ describe("post", () => {
     expect(el.payload?.result).toEqual({ ok: true });
   });
 
+  it("expose un send local avec le body courant", async () => {
+    const bodyPubId = "postSpecLocalSend";
+    const pub = PublisherManager.get(bodyPubId);
+    pub.set({ value: "first" });
+    const bodyKey = new DataProviderKey<{ value: string }>(bodyPubId);
+    const syncEp = new Endpoint<{ ok: boolean }>("items/local-send");
+    const localPost = post(syncEp, bodyKey);
+    const tag = "test-api-post-local-send";
+
+    class C extends HTMLElement {
+      @localPost
+      payload: ApiResult<{ ok: boolean }> | null = null;
+    }
+    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();
+    vi.mocked(API.prototype.postDetailed).mockClear();
+
+    pub.set({ value: "second" });
+    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 () => {
+    const bodyPubId = "postSpecMethodSend";
+    const pub = PublisherManager.get(bodyPubId);
+    pub.set({ value: "first" });
+    const bodyKey = new DataProviderKey<{ value: string }>(bodyPubId);
+    const syncEp = new Endpoint<{ ok: boolean }>("items/method-send");
+    const localPost = post(syncEp, bodyKey);
+    const tag = "test-api-post-method-send";
+
+    class C extends HTMLElement {
+      @localPost
+      payload: ApiResult<{ ok: boolean }> | null = null;
+
+      @send(localPost)
+      async save() {
+        await Promise.resolve();
+        pub.set({ value: "after" });
+      }
+    }
+    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();
+    vi.mocked(API.prototype.postDetailed).mockClear();
+
+    await el.save();
+    await flushSendFrames();
+
+    expect(API.prototype.postDetailed).toHaveBeenCalledWith(
+      "items/method-send",
+      { value: "after" },
+    );
+  });
+
   it("endpoint dynamique et relance quand le body publisher mute", async () => {
     const bodyPubId = "postSpecBody2";
     const pub = PublisherManager.get(bodyPubId);

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

@@ -6,7 +6,7 @@ import API, {
   type ApiResult,
 } from "@supersoniks/concorde/core/utils/api";
 import { PublisherManager } from "@supersoniks/concorde/core/utils/PublisherProxy";
-import { get } from "./api";
+import { get, refetch } from "./api";
 
 const staticConfig: APIConfiguration = {
   serviceURL: "https://api.example.test",
@@ -190,6 +190,146 @@ describe("get", () => {
     expect(el.payload?.result).toEqual({ id: "loaded" });
   });
 
+  it("expose un refetch local avant et après le premier payload", async () => {
+    const pubId = "getSpecLocalRefetch";
+    PublisherManager.get(pubId).set(staticConfig);
+    const confKey = new DataProviderKey<APIConfiguration>(pubId);
+    const itemEp = new Endpoint<{ id: string }>("items/local");
+    const localGet = get(itemEp, confKey);
+    const tag = "test-api-get-local-refetch";
+
+    class C extends HTMLElement {
+      @localGet
+      payload: ApiResult<{ id: string }> | null = null;
+    }
+    if (!customElements.get(tag)) {
+      customElements.define(tag, C);
+    }
+
+    const el = document.createElement(tag) as InstanceType<typeof C>;
+    document.body.appendChild(el);
+
+    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" });
+    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" });
+  });
+
+  it("ne refait plus de GET avec un handle local après déconnexion", async () => {
+    const pubId = "getSpecLocalRefetchDisconnect";
+    PublisherManager.get(pubId).set(staticConfig);
+    const confKey = new DataProviderKey<APIConfiguration>(pubId);
+    const localGet = get(
+      new Endpoint<{ id: string }>("items/local-disconnect"),
+      confKey,
+    );
+    const tag = "test-api-get-local-refetch-disconnect";
+
+    class C extends HTMLElement {
+      @localGet
+      payload: ApiResult<{ id: string }> | null = null;
+    }
+    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();
+
+    el.remove();
+    await localGet.refetch(el);
+
+    expect(API.prototype.getDetailed).not.toHaveBeenCalled();
+  });
+
+  it("peut décorer une méthode et refetcher après sa résolution", async () => {
+    const pubId = "getSpecMethodRefetch";
+    PublisherManager.get(pubId).set(staticConfig);
+    const confKey = new DataProviderKey<APIConfiguration>(pubId);
+    const rowEp = new Endpoint<{ id: string }, { rowId: string }>(
+      "rows/${rowId}",
+    );
+    const localGet = get(rowEp, confKey);
+    const tag = "test-api-get-method-refetch";
+
+    class C extends HTMLElement {
+      rowId = "42";
+
+      @localGet
+      payload: ApiResult<{ id: string }> | null = null;
+
+      @refetch(localGet)
+      async reload() {
+        await Promise.resolve();
+        this.rowId = "84";
+      }
+    }
+    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();
+
+    await el.reload();
+    await flushGetFrames();
+
+    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");