@supersoniks/concorde 4.9.92 → 4.9.94

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

@@ -0,0 +1,73 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import API, { type APIConfiguration } from "./api";
+
+const baseConfig: APIConfiguration = {
+  serviceURL: "https://api.example.test",
+  token: null,
+  userName: null,
+  password: null,
+  authToken: null,
+  tokenProvider: null,
+};
+
+afterEach(() => {
+  vi.restoreAllMocks();
+  vi.unstubAllGlobals();
+});
+
+describe("API GET synchronization", () => {
+  it("deduplicates fetch while sharing the response metadata", async () => {
+    const response = new Response(JSON.stringify({ items: [1, 2] }), {
+      status: 200,
+      headers: { "Content-Type": "application/json" },
+    });
+    const fetchMock = vi.fn().mockResolvedValue(response);
+    vi.stubGlobal("fetch", fetchMock);
+
+    const firstApi = new API({
+      ...baseConfig,
+      serviceURL: "https://api.example.test/concurrent",
+    });
+    const secondApi = new API({
+      ...baseConfig,
+      serviceURL: "https://api.example.test/concurrent",
+    });
+
+    const [firstPayload, secondPayload] = await Promise.all([
+      firstApi.getDetailed<{ items: number[] }>("items"),
+      secondApi.getDetailed<{ items: number[] }>("items"),
+    ]);
+
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    expect(firstPayload?.response?.status).toBe(200);
+    expect(secondPayload?.response?.status).toBe(200);
+    expect(firstPayload?.result).toEqual({ items: [1, 2] });
+    expect(secondPayload?.result).toEqual({ items: [1, 2] });
+  });
+
+  it("permet un nouvel appel après une erreur réseau", async () => {
+    const response = new Response(JSON.stringify({ ok: true }), {
+      status: 200,
+      headers: { "Content-Type": "application/json" },
+    });
+    const fetchMock = vi
+      .fn()
+      .mockRejectedValueOnce(new Error("offline"))
+      .mockResolvedValueOnce(response);
+    vi.stubGlobal("fetch", fetchMock);
+
+    const api = new API({
+      ...baseConfig,
+      serviceURL: "https://api.example.test/recover",
+    });
+
+    await expect(api.getDetailed<{ ok: boolean }>("items")).resolves.toBe(
+      undefined,
+    );
+    const payload = await api.getDetailed<{ ok: boolean }>("items");
+
+    expect(fetchMock).toHaveBeenCalledTimes(2);
+    expect(payload?.response?.status).toBe(200);
+    expect(payload?.result).toEqual({ ok: true });
+  });
+});

package/src/core/utils/api.ts

@@ -49,6 +49,11 @@ export type ApiResult<T> = {
 /** @deprecated Utiliser `ApiResult`. */
 export type ApiGetResult<T> = ApiResult<T>;
 
+type SharedGetResult = {
+  processed: ResultTypeInterface;
+  response?: Response;
+};
+
 /** Extrait le corps typé depuis le résultat traité par `handleResult`. */
 function extractTypedApiResult<T>(
   processed: ResultTypeInterface | null | undefined,
@@ -67,7 +72,10 @@ class API {
   /**
    * Ce tableau static permet de ne pas appeler plusieurs fois le même service lors d'appel concurrents en GET.
    */
-  private static loadingGetPromises: Map<string, Promise<unknown>> = new Map();
+  private static loadingGetPromises: Map<
+    string,
+    Promise<SharedGetResult | null>
+  > = new Map();
   /**
    * L'url de base du service sans endpoint
    */
@@ -202,10 +210,14 @@ class API {
     if (httpCode === 498 && !API.failledTokenUpdates.has(this.serviceURL)) {
       this.handleInvalidToken(this.token);
       if (lastCall.apiMethod === "get") {
-        result = await this[lastCall.apiMethod](
+        const retryResult = await this.get(
           lastCall.path,
           lastCall.additionalHeaders,
         );
+        if (retryResult == null) {
+          throw new Error("GET retry failed after token refresh");
+        }
+        result = retryResult;
       } else {
         result = await this[lastCall.apiMethod](
           lastCall.path,
@@ -384,13 +396,16 @@ class API {
     });
   }
 
-  async get<T>(path: string, additionalHeaders?: HeadersInit) {
-    await this.firstCallDone();
-    if (this.blockUntilDone) {
-      API.firstCallDoneFlags.set(this.serviceURL, "loading");
-    }
+  async get<T>(
+    path: string,
+    additionalHeaders?: HeadersInit,
+  ): Promise<(T & ResultTypeInterface) | null> {
     const regExp = /dataProvider\((.*?)\)(.*?)$/;
     if (regExp.test(path)) {
+      if (this.blockUntilDone) {
+        await this.firstCallDone();
+        API.firstCallDoneFlags.set(this.serviceURL, "loading");
+      }
       const match = path.match(regExp);
       if (!match) throw new Error("dataProvider path is not valid");
       return await this.localGet<T>(match[1], match[2]);
@@ -405,9 +420,21 @@ class API {
     const mapKey = JSON.stringify({
       url: url,
       headers: headers,
+      credentials: this.credentials,
+      cache: this.cache,
+      keepAlive: this.keepAlive,
     });
+
+    // Les GET non bloquants doivent pouvoir rejoindre une requête déjà en vol.
+    // Sinon firstCallDone() sérialise les appels avant que la map de déduplication
+    // ne soit consultée, ce qui déclenche deux fetch pour deux consommateurs.
+    if (this.blockUntilDone) {
+      await this.firstCallDone();
+      API.firstCallDoneFlags.set(this.serviceURL, "loading");
+    }
+
     if (!API.loadingGetPromises.has(mapKey)) {
-      const promise = new Promise(async (resolve) => {
+      const promise = new Promise<SharedGetResult | null>(async (resolve) => {
         try {
           const result = await fetch(url, {
             headers: headers,
@@ -416,16 +443,22 @@ class API {
             keepalive: this.keepAlive,
           });
           const handledResult = await this.handleResult(result, lastCall);
-          resolve(handledResult);
+          resolve({
+            processed: handledResult,
+            response: this.lastResult,
+          });
         } catch (e) {
+          API.firstCallDoneFlags.set(this.serviceURL, "error");
           resolve(null);
         }
       });
       API.loadingGetPromises.set(mapKey, promise);
     }
-    const result = (await API.loadingGetPromises.get(mapKey)) as T;
+    const sharedResult = await API.loadingGetPromises.get(mapKey);
     API.loadingGetPromises.delete(mapKey);
-    return result as T & ResultTypeInterface;
+    if (!sharedResult) return null;
+    this.lastResult = sharedResult.response;
+    return sharedResult.processed as T & ResultTypeInterface;
   }
 
   /**

package/src/core/utils/derive.spec.ts

@@ -0,0 +1,190 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { DataProviderKey } from "@supersoniks/concorde/core/utils/dataProviderKey";
+import {
+  derive,
+  deriveStateKey,
+} from "@supersoniks/concorde/core/utils/derive";
+import { dp, set } from "@supersoniks/concorde/utils";
+
+const sessionsKey = new DataProviderKey<
+  Array<{ title: string; revenue: number }>
+>("derive-sessions");
+const formKey = new DataProviderKey<{ top: number }>("derive-form");
+const outKey = new DataProviderKey<Array<{ title: string; ca: number }>>(
+  "derive-out",
+);
+const outBKey = new DataProviderKey<unknown>("derive-out-b");
+
+function wait(ms: number) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+afterEach(() => {
+  // Nettoyage des DPs de test
+  set(sessionsKey, []);
+  set(formKey, { top: 5 });
+  set(outKey, []);
+});
+
+describe("derive", () => {
+  it("publie un résultat calculé à partir des entrées", async () => {
+    set(sessionsKey, [
+      { title: "A", revenue: 10 },
+      { title: "B", revenue: 30 },
+    ]);
+    set(formKey, { top: 1 });
+
+    const handle = derive({
+      inputs: { s: sessionsKey },
+      variables: formKey,
+      output: outKey,
+      debounceMs: 10,
+      compute: (i, v) =>
+        [...i.s]
+          .sort((a, b) => b.revenue - a.revenue)
+          .slice(0, v.top)
+          .map((x) => ({ title: x.title, ca: x.revenue })),
+    });
+
+    await wait(40);
+    expect(dp(outKey).get()).toEqual([{ title: "B", ca: 30 }]);
+    expect(dp(deriveStateKey(outKey)).get().status).toBe("ready");
+    handle.stop();
+  });
+
+  it("recalcule quand les variables changent (sans toucher aux entrées)", async () => {
+    set(sessionsKey, [
+      { title: "A", revenue: 10 },
+      { title: "B", revenue: 30 },
+      { title: "C", revenue: 20 },
+    ]);
+    set(formKey, { top: 2 });
+
+    const handle = derive({
+      inputs: { s: sessionsKey },
+      variables: formKey,
+      output: outKey,
+      debounceMs: 10,
+      compute: (i, v) =>
+        [...i.s]
+          .sort((a, b) => b.revenue - a.revenue)
+          .slice(0, Number(v.top))
+          .map((x) => ({ title: x.title, ca: x.revenue })),
+    });
+
+    await wait(40);
+    expect(dp(outKey).get()).toHaveLength(2);
+
+    // Comme sonic-input : écriture sur la sous-clé, pas set() racine
+    dp(formKey).top.set(1);
+    await wait(40);
+    expect(dp(outKey).get()).toEqual([{ title: "B", ca: 30 }]);
+    handle.stop();
+  });
+
+  it("debounce + génération : seul le dernier calcul compte", async () => {
+    set(sessionsKey, [{ title: "A", revenue: 1 }]);
+    let calls = 0;
+
+    const handle = derive({
+      inputs: { s: sessionsKey },
+      output: outKey,
+      debounceMs: 30,
+      compute: async (i) => {
+        calls += 1;
+        const n = calls;
+        await wait(40);
+        return i.s.map((x) => ({ title: x.title + n, ca: x.revenue }));
+      },
+    });
+
+    await wait(5);
+    set(sessionsKey, [{ title: "B", revenue: 2 }]);
+    await wait(5);
+    set(sessionsKey, [{ title: "C", revenue: 3 }]);
+    await wait(120);
+
+    const result = dp(outKey).get();
+    expect(result?.[0]?.title).toMatch(/^C/);
+    handle.stop();
+  });
+
+  it("refuse un cycle direct sortie ∈ entrées", () => {
+    expect(() =>
+      derive({
+        inputs: { o: outKey },
+        output: outKey,
+        compute: (i) => i.o,
+      }),
+    ).toThrow(/Cycle/);
+  });
+
+  it("refuse un cycle en chaîne", () => {
+    const a = new DataProviderKey<number>("derive-cycle-a");
+    const b = new DataProviderKey<number>("derive-cycle-b");
+    const h1 = derive({
+      inputs: { a },
+      output: b,
+      debounceMs: 5,
+      compute: (i) => i.a + 1,
+    });
+    expect(() =>
+      derive({
+        inputs: { b },
+        output: a,
+        compute: (i) => (i.b as number) + 1,
+      }),
+    ).toThrow(/Cycle/);
+    h1.stop();
+  });
+
+  it("sortie readonly : écriture externe ignorée + warning", async () => {
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    set(sessionsKey, [{ title: "A", revenue: 5 }]);
+    const handle = derive({
+      inputs: { s: sessionsKey },
+      output: outKey,
+      debounceMs: 10,
+      compute: (i) => i.s.map((x) => ({ title: x.title, ca: x.revenue })),
+    });
+    await wait(40);
+    expect(dp(outKey).get()).toEqual([{ title: "A", ca: 5 }]);
+
+    set(outKey, [{ title: "HACK", ca: 0 }]);
+    await wait(10);
+    expect(dp(outKey).get()).toEqual([{ title: "A", ca: 5 }]);
+    expect(warn).toHaveBeenCalled();
+    warn.mockRestore();
+    handle.stop();
+  });
+
+  it("publie status error puis empty", async () => {
+    const errSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+    set(sessionsKey, [{ title: "A", revenue: 1 }]);
+    const handle = derive({
+      inputs: { s: sessionsKey },
+      output: outBKey,
+      debounceMs: 10,
+      compute: () => {
+        throw new Error("boom-jsonata");
+      },
+    });
+    await wait(40);
+    expect(dp(deriveStateKey(outBKey)).get()).toMatchObject({
+      status: "error",
+      error: expect.stringContaining("boom-jsonata"),
+    });
+    handle.stop();
+    errSpy.mockRestore();
+
+    const handle2 = derive({
+      inputs: { s: sessionsKey },
+      output: outKey,
+      debounceMs: 10,
+      compute: () => [],
+    });
+    await wait(40);
+    expect(dp(deriveStateKey(outKey)).get().status).toBe("empty");
+    handle2.stop();
+  });
+});