@supersoniks/concorde 4.9.91 → 4.9.93

package/src/core/decorators/api.ts

@@ -83,14 +83,32 @@ function isLitHost(component: unknown): component is LitHost {
  * `rebindAll`, etc.) en un seul appel par frame — même principe que
  * `dynamicPropertyWatch.ts` (`scheduleObservedPropertyChanges`).
  */
-function createAnimationFrameCoalescedRunner(run: () => void): () => void {
+function createAnimationFrameCoalescedRunner<T>(
+  run: () => Promise<T>,
+): () => Promise<T> {
   let frameId: number | null = null;
+  let pending: Array<{
+    resolve: (value: T) => void;
+    reject: (reason: unknown) => void;
+  }> = [];
+
   return () => {
-    if (frameId !== null) return;
+    const promise = new Promise<T>((resolve, reject) => {
+      pending.push({ resolve, reject });
+    });
+
+    if (frameId !== null) return promise;
     frameId = requestAnimationFrame(() => {
       frameId = null;
-      run();
+      const current = pending;
+      pending = [];
+      void run().then(
+        (value) => current.forEach(({ resolve }) => resolve(value)),
+        (reason) => current.forEach(({ reject }) => reject(reason)),
+      );
     });
+
+    return promise;
   };
 }
 
@@ -168,8 +186,7 @@ type TriggerPublisherBinding = {
 };
 
 type OperationBinding = {
-  component: object;
-  run: () => void;
+  run: () => Promise<unknown>;
 };
 
 /**
@@ -182,8 +199,8 @@ type OperationBinding = {
 class ApiOperationController {
   private readonly bindings = new WeakMap<object, Set<OperationBinding>>();
 
-  bind(component: object, run: () => void): () => void {
-    const binding: OperationBinding = { component, run };
+  bind(component: object, run: () => Promise<unknown>): () => void {
+    const binding: OperationBinding = { run };
     let componentBindings = this.bindings.get(component);
     if (!componentBindings) {
       componentBindings = new Set();
@@ -201,48 +218,94 @@ class ApiOperationController {
     };
   }
 
-  run(component: object): void {
-    this.bindings.get(component)?.forEach(({ run }) => run());
+  run(component: object): Promise<unknown> {
+    const runs = [...(this.bindings.get(component) ?? [])].map(({ run }) =>
+      run(),
+    );
+    if (runs.length === 0) return Promise.resolve(undefined);
+    if (runs.length === 1) return runs[0];
+    return Promise.all(runs).then(() => undefined);
   }
 }
 
-type ApiPropertyDecorator<T, Host extends object> = <K extends string>(
-  target: Host & {
-    [P in K]?: ApiResult<T> | null | undefined;
-  },
-  propertyKey: K,
-) => void;
-
-export type GetDecoratorHandle<T, Host extends object = object> =
-  ApiPropertyDecorator<T, Host> & {
-    /**
-     * Relance le GET pour cette instance connectée.
-     *
+type ApiHandlerMethod<T> = (this: object, payload?: ApiResult<T>) => void;
+
+export interface GetDecoratorHandle<T, Host extends object = object> {
+  (
+    target: object,
+    propertyKey: string | symbol,
+    descriptor: TypedPropertyDescriptor<ApiHandlerMethod<T>>,
+  ): void;
+  <K extends string>(
+    target: Host & {
+      [P in K]?: ApiResult<T> | null | undefined;
+    },
+    propertyKey: K,
+  ): void;
+  /**
+   * Relance le GET pour cette instance connectée.
+   *
      * Le handle peut être conservé :
      * `const usersGet = get(new Endpoint<User[]>("users"))`.
-     */
-    refetch(component: Host): void;
-  };
-
-export type ApiSendDecoratorHandle<T, Host extends object = object> =
-  ApiPropertyDecorator<T, Host> & {
-    /**
-     * Relance l'opération d'écriture avec le body courant.
      *
+   * La Promise est résolue après la fin du GET.
+   */
+  refetch(component: Host): Promise<ApiResult<T> | undefined>;
+}
+
+type ApiResultHandler<T> = (
+  component: object,
+  payload: ApiResult<T> | undefined,
+) => void;
+
+type GetDecoratorHandleInternals<
+  T,
+  Host extends object = object,
+> = GetDecoratorHandle<T, Host> & {
+  registerResultHandler(target: object, handler: ApiResultHandler<T>): void;
+};
+
+type ApiSendDecoratorHandleInternals<
+  T,
+  Host extends object = object,
+> = ApiSendDecoratorHandle<T, Host> & {
+  registerResultHandler(target: object, handler: ApiResultHandler<T>): void;
+};
+
+let nextApiHandlerPropertyId = 0;
+
+export interface ApiSendDecoratorHandle<T, Host extends object = object> {
+  (
+    target: object,
+    propertyKey: string | symbol,
+    descriptor: TypedPropertyDescriptor<ApiHandlerMethod<T>>,
+  ): void;
+  <K extends string>(
+    target: Host & {
+      [P in K]?: ApiResult<T> | null | undefined;
+    },
+    propertyKey: K,
+  ): void;
+  /**
+   * Relance l'opération d'écriture avec le body courant.
+   *
      * Disponible avec `post`, `put` et `patch`.
-     */
-    send(component: Host): void;
-  };
+   * La Promise est résolue après la fin de l'opération.
+   */
+  send(component: Host): Promise<ApiResult<T> | undefined>;
+}
 
 export type ApiMethodActionOptions = {
   /**
    * Moment du déclenchement par rapport à la méthode.
-   * `after` est la valeur par défaut ; avec une Promise, l'action attend sa résolution.
+   * `after` est la valeur par défaut ; l'action attend la résolution d'une
+   * Promise retournée par la méthode.
+   * Avec `before`, l'action est terminée avant l'appel de la méthode.
    */
   when?: "before" | "after";
 };
 
-type ApiMethod = (this: object, ...args: any[]) => unknown;
+type ApiMethod = (this: object, ...args: unknown[]) => unknown;
 
 function isPromiseLike(value: unknown): value is PromiseLike<unknown> {
   return (
@@ -253,7 +316,7 @@ function isPromiseLike(value: unknown): value is PromiseLike<unknown> {
 }
 
 function createApiMethodActionDecorator(
-  action: (component: object) => void,
+  action: (component: object) => Promise<unknown>,
   options?: ApiMethodActionOptions,
 ): MethodDecorator {
   const when = options?.when ?? "after";
@@ -262,22 +325,19 @@ function createApiMethodActionDecorator(
     const original = descriptor.value as ApiMethod | undefined;
     if (!original) return;
 
-    const wrapped = function (this: object, ...args: any[]) {
+    const wrapped = function (this: object, ...args: unknown[]) {
       if (when === "before") {
-        action(this);
-        return original.apply(this, args);
+        return action(this).then(() => original.apply(this, args));
       }
 
       const result = original.apply(this, args);
       if (isPromiseLike(result)) {
         return result.then((value) => {
-          action(this);
-          return value;
+          return action(this).then(() => value);
         });
       }
 
-      action(this);
-      return result;
+      return action(this).then(() => result);
     };
     descriptor.value = wrapped as unknown as typeof descriptor.value;
   };
@@ -328,7 +388,7 @@ function detachConfigPublisher(state: ApiGetState): void {
 
 /**
  * Décorateur **`@get`** : charge des données via `API.getDetailed` et assigne un
- * `ApiResult<T>` (`request`, `response`, `result` typé `T`) ou `null`.
+ * `ApiResult<T>` (`request`, `response`, `result` typé `T`) ou `undefined`.
  * Le path est un `Endpoint<T, Ue>` ; les placeholders `${nomPropriété}` sont résolus sur l'instance (`Ue` contraint l’hôte).
  *
  * **Scoped (défaut)** : `HTML.getApiConfiguration(host)` avec `host` = l’élément connecté
@@ -350,6 +410,9 @@ function detachConfigPublisher(state: ApiGetState): void {
  * @get(new Endpoint<User, { userId: string }>("users/${userId}"))
  * payload?: ApiResult<User>;
  *
+ * @get(new Endpoint<User[]>("users"))
+ * onUsers(payload?: ApiResult<User[]>) {}
+ *
  * @example
  * const apiConf = new DataProviderKey<APIConfiguration>("myApiConf");
  * PublisherManager.get("myApiConf").set({ serviceURL: "...", token: null, ... });
@@ -362,7 +425,7 @@ function detachConfigPublisher(state: ApiGetState): void {
  * payload?: ApiResult<User[]>;
  *
  * refresh() {
- *   usersGet.refetch(this);
+ *   await usersGet.refetch(this);
  * }
  *
  * @example
@@ -376,10 +439,7 @@ export function get<T, Ue = any>(
 export function get<T, Ue = any, Uk = any>(
   endpoint: Endpoint<T, Ue>,
   configurationKey: DataProviderKey<APIConfiguration, Uk>,
-): GetDecoratorHandle<
-  T,
-  DataProviderKeyHost<Ue> & DataProviderKeyHost<Uk>
->;
+): GetDecoratorHandle<T, DataProviderKeyHost<Ue> & DataProviderKeyHost<Uk>>;
 export function get<T, Ue = any, Uk = any>(
   endpoint: Endpoint<T, Ue>,
   options: GetOptions,
@@ -388,15 +448,11 @@ export function get<T, Ue = any, Uk = any, Ut = any>(
   endpoint: Endpoint<T, Ue>,
   configurationKey: DataProviderKey<APIConfiguration, Uk>,
   options: GetOptions,
-): GetDecoratorHandle<
-  T,
-  DataProviderKeyHost<Ue> & DataProviderKeyHost<Uk>
->;
+): GetDecoratorHandle<T, DataProviderKeyHost<Ue> & DataProviderKeyHost<Uk>>;
 export function get<T, Ue = any, Uk = any, _Ut = any>(
   endpoint: Endpoint<T, Ue>,
   configurationKeyOrOptions?:
-    | DataProviderKey<APIConfiguration, Uk>
-    | GetOptions,
+    DataProviderKey<APIConfiguration, Uk> | GetOptions,
   maybeOptions?: GetOptions,
 ): GetDecoratorHandle<T, object> {
   const pathTemplate = endpoint.path;
@@ -429,9 +485,33 @@ export function get<T, Ue = any, Uk = any, _Ut = any>(
   const usesPublisherConfig = Boolean(configurationKeyPath);
   const refetchEveryMs = options?.refetchEveryMs ?? 0;
   const operationController = new ApiOperationController();
-
-  const decorator = function (target: object, propertyKey: string) {
+  const resultHandlers = new WeakMap<object, Set<ApiResultHandler<T>>>();
+  const decoratedTargets = new WeakSet<object>();
+  const operationPropertyKeys = new WeakMap<object, Set<string>>();
+  let handlerPropertyKey: string | undefined;
+
+  const decorator = function (
+    target: object,
+    propertyKey: string,
+    descriptor?: PropertyDescriptor,
+  ) {
+    if (descriptor) {
+      const handler = descriptor.value as ApiHandlerMethod<T> | undefined;
+      if (!handler) return;
+
+      (decorator as GetDecoratorHandleInternals<T>).registerResultHandler(
+        target,
+        (component, payload) => handler.call(component, payload),
+      );
+      return;
+    }
     if (!target) return;
+    if (decoratedTargets.has(target)) {
+      operationPropertyKeys.get(target)?.add(propertyKey);
+      return;
+    }
+    decoratedTargets.add(target);
+    operationPropertyKeys.set(target, new Set([propertyKey]));
     setSubscribable(target);
     const stateKey = `__get_state_${propertyKey}`;
 
@@ -467,18 +547,24 @@ export function get<T, Ue = any, Uk = any, _Ut = any>(
         if (!state.refetchEveryMs || state.refetchEveryMs <= 0) return;
         state.refetchTimeoutId = setTimeout(() => {
           state.refetchTimeoutId = null;
-          runFetch();
+          void runFetch().catch(() => {});
         }, state.refetchEveryMs);
       };
 
-      const runFetch = () => {
+      const assignPayload = (payload: ApiResult<T> | undefined) => {
+        operationPropertyKeys.get(target)?.forEach((key) => {
+          comp[key] = payload;
+        });
+      };
+
+      const runFetch = async (): Promise<ApiResult<T> | undefined> => {
         const resolution = isDynamicPath
           ? resolveDynamicPath(component, pathTemplate, pathOptions)
           : { ready: true, path: pathTemplate };
         if (!resolution.ready || !resolution.path) {
-          comp[propertyKey] = undefined;
+          assignPayload(undefined);
           scheduleRefetch();
-          return;
+          return undefined;
         }
         let config: APIConfiguration | null = null;
         if (usesPublisherConfig && configurationKeyPath) {
@@ -488,9 +574,9 @@ export function get<T, Ue = any, Uk = any, _Ut = any>(
             pathOptions,
           );
           if (!configRes.ready || !configRes.path) {
-            comp[propertyKey] = undefined;
+            assignPayload(undefined);
             scheduleRefetch();
-            return;
+            return undefined;
           }
           const configPublisher = getPublisherFromPath(configRes.path);
           config = readApiConfigurationFromPublisher(configPublisher);
@@ -499,7 +585,10 @@ export function get<T, Ue = any, Uk = any, _Ut = any>(
         }
         if (!isScopedConfigurationReady(config)) {
           if (!usesPublisherConfig && !state.scopeWatchCleanup) {
-            const scopeWatch = watchScopedConfiguration(component, runFetch);
+            const scopeWatch = watchScopedConfiguration(
+              component,
+              scheduleFetchAndIgnoreErrors,
+            );
             state.scopeWatchCleanup = scopeWatch;
             state.cleanupWatchers.push(() => {
               scopeWatch();
@@ -507,20 +596,26 @@ export function get<T, Ue = any, Uk = any, _Ut = any>(
             });
           }
           scheduleRefetch();
-          return;
+          return undefined;
         }
         const generation = ++state.requestGeneration;
         const api = new API(config);
-        void api
-          .getDetailed<T>(resolution.path)
-          .then((payload?: ApiResult<T>) => {
-            if (generation !== state.requestGeneration) return;
-            comp[propertyKey] = payload;
-            scheduleRefetch();
-          });
+        const payload = await api.getDetailed<T>(resolution.path);
+        if (generation !== state.requestGeneration) return payload;
+        operationPropertyKeys.get(target)?.forEach((key) => {
+          comp[key] = payload;
+        });
+        scheduleRefetch();
+        resultHandlers
+          .get(target)
+          ?.forEach((handler) => handler(component, payload));
+        return payload;
       };
 
       const scheduleFetch = createAnimationFrameCoalescedRunner(runFetch);
+      const scheduleFetchAndIgnoreErrors = () => {
+        void scheduleFetch().catch(() => {});
+      };
       state.cleanupOperation = operationController.bind(
         component,
         scheduleFetch,
@@ -539,7 +634,7 @@ export function get<T, Ue = any, Uk = any, _Ut = any>(
         }
         const publisher = getPublisherFromPath(triggerResolution.path);
         if (!publisher) return;
-        const invalidateHandler = () => scheduleFetch();
+        const invalidateHandler = scheduleFetchAndIgnoreErrors;
         publisher.onInvalidate(invalidateHandler);
         state.triggerPublisher = publisher;
         state.triggerInvalidateHandler = invalidateHandler;
@@ -554,15 +649,15 @@ export function get<T, Ue = any, Uk = any, _Ut = any>(
           pathOptions,
         );
         if (!configRes.ready || !configRes.path) {
-          comp[propertyKey] = undefined;
+          assignPayload(undefined);
           return;
         }
         const publisher = getPublisherFromPath(configRes.path);
         if (!publisher) {
-          comp[propertyKey] = undefined;
+          assignPayload(undefined);
           return;
         }
-        const mutationHandler = () => scheduleFetch();
+        const mutationHandler = scheduleFetchAndIgnoreErrors;
         publisher.onInternalMutation(mutationHandler);
         state.configPublisher = publisher;
         state.configMutationHandler = mutationHandler;
@@ -572,7 +667,7 @@ export function get<T, Ue = any, Uk = any, _Ut = any>(
         rebindTriggerPublisher();
         rebindPublisherConfig();
         if (!usesPublisherConfig) {
-          scheduleFetch();
+          scheduleFetchAndIgnoreErrors();
         }
       };
 
@@ -597,13 +692,13 @@ export function get<T, Ue = any, Uk = any, _Ut = any>(
                 getDynamicWatchKeys.hooked,
                 component,
                 dependency,
-                () => scheduleFetch(),
+                scheduleFetchAndIgnoreErrors,
               );
               state.cleanupWatchers.push(unsubscribe);
             }
           }
           rebindTriggerPublisher();
-          runFetch();
+          void runFetch().catch(() => {});
         };
         state.cleanupWatchers.push(
           scheduleAfterHostReady(component, startScopedFetch),
@@ -623,12 +718,30 @@ export function get<T, Ue = any, Uk = any, _Ut = any>(
       state.cleanupWatchers.forEach((cleanup) => cleanup());
       state.cleanupWatchers = [];
       state.requestGeneration++;
-      comp[propertyKey] = undefined;
+      operationPropertyKeys.get(target)?.forEach((key) => {
+        comp[key] = undefined;
+      });
     });
-  } as GetDecoratorHandle<T, object>;
+  } as GetDecoratorHandleInternals<T>;
 
   decorator.refetch = (component: object) => {
-    operationController.run(component);
+    return operationController.run(component) as Promise<
+      ApiResult<T> | undefined
+    >;
+  };
+
+  decorator.registerResultHandler = (target, handler) => {
+    let handlers = resultHandlers.get(target);
+    if (!handlers) {
+      handlers = new Set();
+      resultHandlers.set(target, handlers);
+    }
+    handlers.add(handler);
+
+    if (!decoratedTargets.has(target)) {
+      handlerPropertyKey ??= `__get_handler_${nextApiHandlerPropertyId++}`;
+      decorator(target, handlerPropertyKey);
+    }
   };
 
   return decorator;
@@ -724,22 +837,21 @@ function readBodyFromPublisher(publisher: DataProvider | null): unknown {
 
 type ApiSendMethod = "POST" | "PUT" | "PATCH";
 
-type ApiSendDetailedCaller = (
+type ApiSendDetailedCaller<T> = (
   api: API,
   path: string,
   body: unknown,
-) => Promise<ApiResult<unknown> | undefined>;
+) => Promise<ApiResult<T> | undefined>;
 
 function createApiSendDecorator<T, B, Ue = any, Uk = any, Ut = any>(
   method: ApiSendMethod,
-  callDetailed: ApiSendDetailedCaller,
+  callDetailed: ApiSendDetailedCaller<T>,
 ) {
   return function (
     endpoint: Endpoint<T, Ue>,
     bodyKey: DataProviderKey<B>,
     configurationKeyOrOptions?:
-      | DataProviderKey<APIConfiguration, Uk>
-      | ApiSendOptions<Ut>,
+      DataProviderKey<APIConfiguration, Uk> | ApiSendOptions<Ut>,
     maybeOptions?: ApiSendOptions<Ut>,
   ): ApiSendDecoratorHandle<T, object> {
     const pathTemplate = endpoint.path;
@@ -779,9 +891,33 @@ function createApiSendDecorator<T, B, Ue = any, Uk = any, Ut = any>(
     };
     const stateKeyPrefix = `__${method.toLowerCase()}_state_`;
     const operationController = new ApiOperationController();
-
-    const decorator = function (target: object, propertyKey: string) {
+    const resultHandlers = new WeakMap<object, Set<ApiResultHandler<T>>>();
+    const decoratedTargets = new WeakSet<object>();
+    const operationPropertyKeys = new WeakMap<object, Set<string>>();
+    let handlerPropertyKey: string | undefined;
+
+    const decorator = function (
+      target: object,
+      propertyKey: string,
+      descriptor?: PropertyDescriptor,
+    ) {
+      if (descriptor) {
+        const handler = descriptor.value as ApiHandlerMethod<T> | undefined;
+        if (!handler) return;
+
+        (decorator as ApiSendDecoratorHandleInternals<T>).registerResultHandler(
+          target,
+          (component, payload) => handler.call(component, payload),
+        );
+        return;
+      }
       if (!target) return;
+      if (decoratedTargets.has(target)) {
+        operationPropertyKeys.get(target)?.add(propertyKey);
+        return;
+      }
+      decoratedTargets.add(target);
+      operationPropertyKeys.set(target, new Set([propertyKey]));
       setSubscribable(target);
       const stateKey = `${stateKeyPrefix}${propertyKey}`;
 
@@ -823,18 +959,24 @@ function createApiSendDecorator<T, B, Ue = any, Uk = any, Ut = any>(
           if (!state.refetchEveryMs || state.refetchEveryMs <= 0) return;
           state.refetchTimeoutId = setTimeout(() => {
             state.refetchTimeoutId = null;
-            runSend();
+            void runSend().catch(() => {});
           }, state.refetchEveryMs);
         };
 
-        const runSend = () => {
+        const assignPayload = (payload: ApiResult<T> | undefined) => {
+          operationPropertyKeys.get(target)?.forEach((key) => {
+            comp[key] = payload;
+          });
+        };
+
+        const runSend = async (): Promise<ApiResult<T> | undefined> => {
           const resolution = isDynamicPath
             ? resolveDynamicPath(component, pathTemplate, pathOptions)
             : { ready: true, path: pathTemplate };
           if (!resolution.ready || !resolution.path) {
-            comp[propertyKey] = undefined;
+            assignPayload(undefined);
             scheduleRefetch();
-            return;
+            return undefined;
           }
 
           const bodyResolution = resolveDynamicPath(
@@ -843,9 +985,9 @@ function createApiSendDecorator<T, B, Ue = any, Uk = any, Ut = any>(
             pathOptions,
           );
           if (!bodyResolution.ready || !bodyResolution.path) {
-            comp[propertyKey] = undefined;
+            assignPayload(undefined);
             scheduleRefetch();
-            return;
+            return undefined;
           }
 
           const bodyPublisher = getPublisherFromPath(bodyResolution.path);
@@ -855,7 +997,7 @@ function createApiSendDecorator<T, B, Ue = any, Uk = any, Ut = any>(
             (body === null || body === undefined)
           ) {
             scheduleRefetch();
-            return;
+            return undefined;
           }
 
           let config: APIConfiguration | null = null;
@@ -866,9 +1008,9 @@ function createApiSendDecorator<T, B, Ue = any, Uk = any, Ut = any>(
               pathOptions,
             );
             if (!configRes.ready || !configRes.path) {
-              comp[propertyKey] = undefined;
+              assignPayload(undefined);
               scheduleRefetch();
-              return;
+              return undefined;
             }
             const configPublisher = getPublisherFromPath(configRes.path);
             config = readApiConfigurationFromPublisher(configPublisher);
@@ -878,7 +1020,10 @@ function createApiSendDecorator<T, B, Ue = any, Uk = any, Ut = any>(
 
           if (!isScopedConfigurationReady(config)) {
             if (!usesPublisherConfig && !state.scopeWatchCleanup) {
-              const scopeWatch = watchScopedConfiguration(component, runSend);
+              const scopeWatch = watchScopedConfiguration(
+                component,
+                scheduleSendAndIgnoreErrors,
+              );
               state.scopeWatchCleanup = scopeWatch;
               state.cleanupWatchers.push(() => {
                 scopeWatch();
@@ -886,21 +1031,35 @@ function createApiSendDecorator<T, B, Ue = any, Uk = any, Ut = any>(
               });
             }
             scheduleRefetch();
-            return;
+            return undefined;
           }
 
           const generation = ++state.requestGeneration;
           const api = new API(config);
-          void callDetailed(api, resolution.path, body).then(
-            (payload?: ApiResult<unknown>) => {
-              if (generation !== state.requestGeneration) return;
-              comp[propertyKey] = payload;
-              scheduleRefetch();
-            },
-          );
+          let payload: ApiResult<T> | undefined;
+          try {
+            payload = await callDetailed(api, resolution.path, body);
+          } catch (error) {
+            if (generation === state.requestGeneration) {
+              resultHandlers
+                .get(target)
+                ?.forEach((handler) => handler(component, undefined));
+            }
+            throw error;
+          }
+          if (generation !== state.requestGeneration) return payload;
+          assignPayload(payload);
+          scheduleRefetch();
+          resultHandlers
+            .get(target)
+            ?.forEach((handler) => handler(component, payload));
+          return payload;
         };
 
         const scheduleSend = createAnimationFrameCoalescedRunner(runSend);
+        const scheduleSendAndIgnoreErrors = () => {
+          void scheduleSend().catch(() => {});
+        };
         state.cleanupOperation = operationController.bind(
           component,
           scheduleSend,
@@ -921,7 +1080,7 @@ function createApiSendDecorator<T, B, Ue = any, Uk = any, Ut = any>(
           }
           const publisher = getPublisherFromPath(bodyResolution.path);
           if (!publisher) return;
-          const mutationHandler = () => scheduleSend();
+          const mutationHandler = scheduleSendAndIgnoreErrors;
           publisher.onInternalMutation(mutationHandler);
           state.bodyPublisher = publisher;
           state.bodyMutationHandler = mutationHandler;
@@ -940,7 +1099,7 @@ function createApiSendDecorator<T, B, Ue = any, Uk = any, Ut = any>(
           }
           const publisher = getPublisherFromPath(triggerResolution.path);
           if (!publisher) return;
-          const invalidateHandler = () => scheduleSend();
+          const invalidateHandler = scheduleSendAndIgnoreErrors;
           publisher.onInvalidate(invalidateHandler);
           state.triggerPublisher = publisher;
           state.triggerInvalidateHandler = invalidateHandler;
@@ -955,15 +1114,15 @@ function createApiSendDecorator<T, B, Ue = any, Uk = any, Ut = any>(
             pathOptions,
           );
           if (!configRes.ready || !configRes.path) {
-            comp[propertyKey] = undefined;
+            assignPayload(undefined);
             return;
           }
           const publisher = getPublisherFromPath(configRes.path);
           if (!publisher) {
-            comp[propertyKey] = undefined;
+            assignPayload(undefined);
             return;
           }
-          const mutationHandler = () => scheduleSend();
+          const mutationHandler = scheduleSendAndIgnoreErrors;
           publisher.onInternalMutation(mutationHandler);
           state.configPublisher = publisher;
           state.configMutationHandler = mutationHandler;
@@ -974,7 +1133,7 @@ function createApiSendDecorator<T, B, Ue = any, Uk = any, Ut = any>(
           rebindTriggerPublisher();
           rebindPublisherConfig();
           if (state.autoPostOnBodyMutation) {
-            scheduleSend();
+            scheduleSendAndIgnoreErrors();
           }
         };
 
@@ -1003,7 +1162,7 @@ function createApiSendDecorator<T, B, Ue = any, Uk = any, Ut = any>(
                   getDynamicWatchKeys.hooked,
                   component,
                   dependency,
-                  () => scheduleSend(),
+                  scheduleSendAndIgnoreErrors,
                 );
                 state.cleanupWatchers.push(unsubscribe);
               }
@@ -1011,7 +1170,7 @@ function createApiSendDecorator<T, B, Ue = any, Uk = any, Ut = any>(
             rebindBodyPublisher();
             rebindTriggerPublisher();
             if (state.autoPostOnBodyMutation) {
-              scheduleSend();
+              scheduleSendAndIgnoreErrors();
             }
           };
           state.cleanupWatchers.push(
@@ -1033,12 +1192,30 @@ function createApiSendDecorator<T, B, Ue = any, Uk = any, Ut = any>(
         state.cleanupWatchers.forEach((cleanup) => cleanup());
         state.cleanupWatchers = [];
         state.requestGeneration++;
-        comp[propertyKey] = undefined;
+        operationPropertyKeys.get(target)?.forEach((key) => {
+          comp[key] = undefined;
+        });
       });
-    } as ApiSendDecoratorHandle<T, object>;
+    } as ApiSendDecoratorHandleInternals<T>;
 
     decorator.send = (component: object) => {
-      operationController.run(component);
+      return operationController.run(component) as Promise<
+        ApiResult<T> | undefined
+      >;
+    };
+
+    decorator.registerResultHandler = (target, handler) => {
+      let handlers = resultHandlers.get(target);
+      if (!handlers) {
+        handlers = new Set();
+        resultHandlers.set(target, handlers);
+      }
+      handlers.add(handler);
+
+      if (!decoratedTargets.has(target)) {
+        handlerPropertyKey ??= `__${method.toLowerCase()}_handler_${nextApiHandlerPropertyId++}`;
+        decorator(target, handlerPropertyKey);
+      }
     };
 
     return decorator;
@@ -1061,7 +1238,7 @@ function createApiSendDecorator<T, B, Ue = any, Uk = any, Ut = any>(
  * @save
  * payload?: ApiResult<User>;
  * // Dans un handler du composant :
- * save.send(this);
+ * await save.send(this);
  */
 export function post<T, B, Ue = any>(
   endpoint: Endpoint<T, Ue>,
@@ -1071,10 +1248,7 @@ export function post<T, B, Ue = any, Uk = any>(
   endpoint: Endpoint<T, Ue>,
   bodyKey: DataProviderKey<B>,
   configurationKey: DataProviderKey<APIConfiguration, Uk>,
-): ApiSendDecoratorHandle<
-  T,
-  DataProviderKeyHost<Ue> & DataProviderKeyHost<Uk>
->;
+): ApiSendDecoratorHandle<T, DataProviderKeyHost<Ue> & DataProviderKeyHost<Uk>>;
 export function post<T, B, Ue = any, Uk = any>(
   endpoint: Endpoint<T, Ue>,
   bodyKey: DataProviderKey<B>,
@@ -1085,16 +1259,12 @@ export function post<T, B, Ue = any, Uk = any, Ut = any>(
   bodyKey: DataProviderKey<B>,
   configurationKey: DataProviderKey<APIConfiguration, Uk>,
   options: PostOptions<Ut>,
-): ApiSendDecoratorHandle<
-  T,
-  DataProviderKeyHost<Ue> & DataProviderKeyHost<Uk>
->;
+): ApiSendDecoratorHandle<T, DataProviderKeyHost<Ue> & DataProviderKeyHost<Uk>>;
 export function post<T, B, Ue = any, Uk = any, Ut = any>(
   endpoint: Endpoint<T, Ue>,
   bodyKey: DataProviderKey<B>,
   configurationKeyOrOptions?:
-    | DataProviderKey<APIConfiguration, Uk>
-    | PostOptions<Ut>,
+    DataProviderKey<APIConfiguration, Uk> | PostOptions<Ut>,
   maybeOptions?: PostOptions<Ut>,
 ): ApiSendDecoratorHandle<T, object> {
   return createApiSendDecorator<T, B, Ue, Uk, Ut>("POST", (api, path, body) =>
@@ -1111,10 +1281,7 @@ export function put<T, B, Ue = any, Uk = any>(
   endpoint: Endpoint<T, Ue>,
   bodyKey: DataProviderKey<B>,
   configurationKey: DataProviderKey<APIConfiguration, Uk>,
-): ApiSendDecoratorHandle<
-  T,
-  DataProviderKeyHost<Ue> & DataProviderKeyHost<Uk>
->;
+): ApiSendDecoratorHandle<T, DataProviderKeyHost<Ue> & DataProviderKeyHost<Uk>>;
 export function put<T, B, Ue = any, Uk = any>(
   endpoint: Endpoint<T, Ue>,
   bodyKey: DataProviderKey<B>,
@@ -1125,16 +1292,12 @@ export function put<T, B, Ue = any, Uk = any, Ut = any>(
   bodyKey: DataProviderKey<B>,
   configurationKey: DataProviderKey<APIConfiguration, Uk>,
   options: PutOptions<Ut>,
-): ApiSendDecoratorHandle<
-  T,
-  DataProviderKeyHost<Ue> & DataProviderKeyHost<Uk>
->;
+): ApiSendDecoratorHandle<T, DataProviderKeyHost<Ue> & DataProviderKeyHost<Uk>>;
 export function put<T, B, Ue = any, Uk = any, Ut = any>(
   endpoint: Endpoint<T, Ue>,
   bodyKey: DataProviderKey<B>,
   configurationKeyOrOptions?:
-    | DataProviderKey<APIConfiguration, Uk>
-    | PutOptions<Ut>,
+    DataProviderKey<APIConfiguration, Uk> | PutOptions<Ut>,
   maybeOptions?: PutOptions<Ut>,
 ): ApiSendDecoratorHandle<T, object> {
   return createApiSendDecorator<T, B, Ue, Uk, Ut>("PUT", (api, path, body) =>
@@ -1151,10 +1314,7 @@ export function patch<T, B, Ue = any, Uk = any>(
   endpoint: Endpoint<T, Ue>,
   bodyKey: DataProviderKey<B>,
   configurationKey: DataProviderKey<APIConfiguration, Uk>,
-): ApiSendDecoratorHandle<
-  T,
-  DataProviderKeyHost<Ue> & DataProviderKeyHost<Uk>
->;
+): ApiSendDecoratorHandle<T, DataProviderKeyHost<Ue> & DataProviderKeyHost<Uk>>;
 export function patch<T, B, Ue = any, Uk = any>(
   endpoint: Endpoint<T, Ue>,
   bodyKey: DataProviderKey<B>,
@@ -1165,16 +1325,12 @@ export function patch<T, B, Ue = any, Uk = any, Ut = any>(
   bodyKey: DataProviderKey<B>,
   configurationKey: DataProviderKey<APIConfiguration, Uk>,
   options: PatchOptions<Ut>,
-): ApiSendDecoratorHandle<
-  T,
-  DataProviderKeyHost<Ue> & DataProviderKeyHost<Uk>
->;
+): ApiSendDecoratorHandle<T, DataProviderKeyHost<Ue> & DataProviderKeyHost<Uk>>;
 export function patch<T, B, Ue = any, Uk = any, Ut = any>(
   endpoint: Endpoint<T, Ue>,
   bodyKey: DataProviderKey<B>,
   configurationKeyOrOptions?:
-    | DataProviderKey<APIConfiguration, Uk>
-    | PatchOptions<Ut>,
+    DataProviderKey<APIConfiguration, Uk> | PatchOptions<Ut>,
   maybeOptions?: PatchOptions<Ut>,
 ): ApiSendDecoratorHandle<T, object> {
   return createApiSendDecorator<T, B, Ue, Uk, Ut>("PATCH", (api, path, body) =>