@supersoniks/concorde 4.7.4 → 4.9.0

package/src/core/decorators/api.ts

@@ -8,11 +8,12 @@ import HTML, {
 } from "@supersoniks/concorde/core/utils/HTML";
 import API, {
   APIConfiguration,
-  type ApiGetResult,
+  type ApiResult,
 } from "@supersoniks/concorde/core/utils/api";
 import DataProvider from "../utils/PublisherProxy";
 import { ConnectedComponent, setSubscribable } from "./subscriber/common";
 import {
+  type DynamicPathOptions,
   extractDynamicDependencies,
   resolveDynamicPath,
 } from "./subscriber/dynamicPath";
@@ -77,6 +78,22 @@ function isLitHost(component: unknown): component is LitHost {
   );
 }
 
+/**
+ * Regroupe plusieurs déclencheurs synchrones (mutations `onInternalMutation`,
+ * `rebindAll`, etc.) en un seul appel par frame — même principe que
+ * `dynamicPropertyWatch.ts` (`scheduleObservedPropertyChanges`).
+ */
+function createAnimationFrameCoalescedRunner(run: () => void): () => void {
+  let frameId: number | null = null;
+  return () => {
+    if (frameId !== null) return;
+    frameId = requestAnimationFrame(() => {
+      frameId = null;
+      run();
+    });
+  };
+}
+
 function scheduleAfterHostReady(
   component: unknown,
   callback: () => void,
@@ -163,7 +180,7 @@ function detachConfigPublisher(state: ApiGetState): void {
 
 /**
  * Décorateur **`@get`** : charge des données via `API.getDetailed` et assigne un
- * `ApiGetResult<T>` (`request`, `response`, `result` typé `T`) ou `null`.
+ * `ApiResult<T>` (`request`, `response`, `result` typé `T`) ou `null`.
  * 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é
@@ -176,19 +193,19 @@ function detachConfigPublisher(state: ApiGetState): void {
  *
  * @example
  * @get(new Endpoint<User, { userId: string }>("users/${userId}"))
- * payload?: ApiGetResult<User>;
+ * payload?: ApiResult<User>;
  *
  * @example
  * const apiConf = new DataProviderKey<APIConfiguration>("myApiConf");
  * PublisherManager.get("myApiConf").set({ serviceURL: "...", token: null, ... });
  * @get(new Endpoint<Thing, { id: string }>("things/${id}"), apiConf)
- * payload?: ApiGetResult<Thing>;
+ * payload?: ApiResult<Thing>;
  */
 export function get<T, Ue = any>(
   endpoint: Endpoint<T, Ue>,
 ): <K extends string>(
   target: DataProviderKeyHost<Ue> & {
-    [P in K]?: ApiGetResult<T> | null | undefined;
+    [P in K]?: ApiResult<T> | null | undefined;
   },
   propertyKey: K,
 ) => void;
@@ -198,18 +215,50 @@ export function get<T, Ue = any, Uk = any>(
 ): <K extends string>(
   target: DataProviderKeyHost<Ue> &
     DataProviderKeyHost<Uk> & {
-      [P in K]?: ApiGetResult<T> | null | undefined;
+      [P in K]?: ApiResult<T> | null | undefined;
     },
   propertyKey: K,
 ) => void;
 export function get<T, Ue = any, Uk = any>(
   endpoint: Endpoint<T, Ue>,
-  configurationKey?: DataProviderKey<APIConfiguration, Uk>,
+  options: GetOptions,
 ): <K extends string>(
-  target: object & { [P in K]?: ApiGetResult<T> | null | undefined },
+  target: DataProviderKeyHost<Ue> & {
+    [P in K]?: ApiResult<T> | null | undefined;
+  },
+  propertyKey: K,
+) => void;
+export function get<T, Ue = any, Uk = any, Ut = any>(
+  endpoint: Endpoint<T, Ue>,
+  configurationKey: DataProviderKey<APIConfiguration, Uk>,
+  options: GetOptions,
+): <K extends string>(
+  target: DataProviderKeyHost<Ue> &
+    DataProviderKeyHost<Uk> & {
+      [P in K]?: ApiResult<T> | null | undefined;
+    },
+  propertyKey: K,
+) => void;
+export function get<T, Ue = any, Uk = any, _Ut = any>(
+  endpoint: Endpoint<T, Ue>,
+  configurationKeyOrOptions?:
+    | DataProviderKey<APIConfiguration, Uk>
+    | GetOptions,
+  maybeOptions?: GetOptions,
+): <K extends string>(
+  target: object & { [P in K]?: ApiResult<T> | null | undefined },
   propertyKey: K,
 ) => void {
   const pathTemplate = endpoint.path;
+  const configurationKey = isGetOptions(configurationKeyOrOptions)
+    ? undefined
+    : configurationKeyOrOptions;
+  const options = isGetOptions(configurationKeyOrOptions)
+    ? configurationKeyOrOptions
+    : maybeOptions;
+  const pathOptions: DynamicPathOptions = {
+    skipEmptyPlaceholder: options?.skipEmptyPlaceholder,
+  };
   const configurationKeyPath = configurationKey?.path;
   const endpointDynamicDependencies = extractDynamicDependencies(pathTemplate);
   const configKeyDynamicDependencies = configurationKeyPath
@@ -249,7 +298,7 @@ export function get<T, Ue = any, Uk = any>(
 
       const runFetch = () => {
         const resolution = isDynamicPath
-          ? resolveDynamicPath(component, pathTemplate)
+          ? resolveDynamicPath(component, pathTemplate, pathOptions)
           : { ready: true, path: pathTemplate };
         if (!resolution.ready || !resolution.path) {
           comp[propertyKey] = undefined;
@@ -257,7 +306,11 @@ export function get<T, Ue = any, Uk = any>(
         }
         let config: APIConfiguration | null = null;
         if (usesPublisherConfig && configurationKeyPath) {
-          const configRes = resolveDynamicPath(component, configurationKeyPath);
+          const configRes = resolveDynamicPath(
+            component,
+            configurationKeyPath,
+            pathOptions,
+          );
           if (!configRes.ready || !configRes.path) {
             comp[propertyKey] = undefined;
             return;
@@ -282,7 +335,7 @@ export function get<T, Ue = any, Uk = any>(
         const api = new API(config);
         void api
           .getDetailed<T>(resolution.path)
-          .then((payload?: ApiGetResult<T>) => {
+          .then((payload?: ApiResult<T>) => {
             if (generation !== state.requestGeneration) return;
             comp[propertyKey] = payload;
           });
@@ -291,7 +344,11 @@ export function get<T, Ue = any, Uk = any>(
       const rebindPublisherConfig = () => {
         if (!usesPublisherConfig || !configurationKeyPath) return;
         detachConfigPublisher(state);
-        const configRes = resolveDynamicPath(component, configurationKeyPath);
+        const configRes = resolveDynamicPath(
+          component,
+          configurationKeyPath,
+          pathOptions,
+        );
         if (!configRes.ready || !configRes.path) {
           comp[propertyKey] = undefined;
           return;
@@ -355,3 +412,575 @@ export function get<T, Ue = any, Uk = any>(
     });
   };
 }
+
+export type GetOptions = DynamicPathOptions;
+
+export type ApiSendOptions<Uk = any> = DynamicPathOptions & {
+  /** Intervalle de renvoi automatique (ms). 0 ou absent = pas de polling. */
+  refetchEveryMs?: number;
+  /** Ne pas envoyer si le body publisher est null/undefined (défaut: true). */
+  skipIfBodyMissing?: boolean;
+  /**
+   * Relancer l'envoi quand le body publisher mute (défaut: true).
+   * `false` : le body est lu au moment de l'envoi ; déclencher via `triggerKey.invalidate()`.
+   */
+  autoPostOnBodyMutation?: boolean;
+  /** Publisher dont `invalidate()` relance l'envoi (relit le body courant). */
+  triggerKey?: DataProviderKey<unknown, Uk>;
+};
+
+/** @deprecated Alias — préférer `ApiSendOptions`. */
+export type PostOptions<Uk = any> = ApiSendOptions<Uk>;
+export type PutOptions<Uk = any> = ApiSendOptions<Uk>;
+export type PatchOptions<Uk = any> = ApiSendOptions<Uk>;
+
+function isGetOptions(value: unknown): value is GetOptions {
+  if (!value || typeof value !== "object") return false;
+  return "skipEmptyPlaceholder" in value;
+}
+
+function isApiSendOptions(value: unknown): value is ApiSendOptions {
+  if (!value || typeof value !== "object") return false;
+  return (
+    "refetchEveryMs" in value ||
+    "skipIfBodyMissing" in value ||
+    "autoPostOnBodyMutation" in value ||
+    "skipEmptyPlaceholder" in value ||
+    "triggerKey" in value
+  );
+}
+
+type ApiSendState = ApiGetState & {
+  bodyPublisher: DataProvider | null;
+  bodyMutationHandler: (() => void) | null;
+  triggerPublisher: DataProvider | null;
+  triggerInvalidateHandler: (() => void) | null;
+  refetchTimeoutId: ReturnType<typeof setTimeout> | null;
+  refetchEveryMs: number;
+  skipIfBodyMissing: boolean;
+  autoPostOnBodyMutation: boolean;
+};
+
+function detachBodyPublisher(state: ApiSendState): void {
+  if (state.bodyPublisher && state.bodyMutationHandler) {
+    state.bodyPublisher.offInternalMutation(state.bodyMutationHandler);
+  }
+  state.bodyPublisher = null;
+  state.bodyMutationHandler = null;
+}
+
+function detachTriggerPublisher(state: ApiSendState): void {
+  if (state.triggerPublisher && state.triggerInvalidateHandler) {
+    state.triggerPublisher.offInvalidate(state.triggerInvalidateHandler);
+  }
+  state.triggerPublisher = null;
+  state.triggerInvalidateHandler = null;
+}
+
+function clearSendRefetch(state: ApiSendState): void {
+  if (state.refetchTimeoutId) {
+    clearTimeout(state.refetchTimeoutId);
+    state.refetchTimeoutId = null;
+  }
+}
+
+function readBodyFromPublisher(publisher: DataProvider | null): unknown {
+  if (!publisher || typeof publisher.get !== "function") return undefined;
+  return publisher.get();
+}
+
+type ApiSendMethod = "POST" | "PUT" | "PATCH";
+
+type ApiSendDetailedCaller = (
+  api: API,
+  path: string,
+  body: unknown,
+) => Promise<ApiResult<unknown> | undefined>;
+
+function createApiSendDecorator<T, B, Ue = any, Uk = any, Ut = any>(
+  method: ApiSendMethod,
+  callDetailed: ApiSendDetailedCaller,
+) {
+  return function (
+    endpoint: Endpoint<T, Ue>,
+    bodyKey: DataProviderKey<B>,
+    configurationKeyOrOptions?:
+      | DataProviderKey<APIConfiguration, Uk>
+      | ApiSendOptions<Ut>,
+    maybeOptions?: ApiSendOptions<Ut>,
+  ): <K extends string>(
+    target: object & { [P in K]?: ApiResult<T> | null | undefined },
+    propertyKey: K,
+  ) => void {
+    const pathTemplate = endpoint.path;
+    const bodyKeyPath = bodyKey.path;
+    const configurationKey = isApiSendOptions(configurationKeyOrOptions)
+      ? undefined
+      : configurationKeyOrOptions;
+    const options = isApiSendOptions(configurationKeyOrOptions)
+      ? configurationKeyOrOptions
+      : maybeOptions;
+    const configurationKeyPath = configurationKey?.path;
+    const triggerKeyPath = options?.triggerKey?.path;
+    const endpointDynamicDependencies =
+      extractDynamicDependencies(pathTemplate);
+    const bodyKeyDynamicDependencies = extractDynamicDependencies(bodyKeyPath);
+    const configKeyDynamicDependencies = configurationKeyPath
+      ? extractDynamicDependencies(configurationKeyPath)
+      : [];
+    const triggerKeyDynamicDependencies = triggerKeyPath
+      ? extractDynamicDependencies(triggerKeyPath)
+      : [];
+    const mergedDynamicDependencies = [
+      ...new Set([
+        ...endpointDynamicDependencies,
+        ...bodyKeyDynamicDependencies,
+        ...configKeyDynamicDependencies,
+        ...triggerKeyDynamicDependencies,
+      ]),
+    ];
+    const isDynamicPath = endpointDynamicDependencies.length > 0;
+    const usesPublisherConfig = Boolean(configurationKeyPath);
+    const refetchEveryMs = options?.refetchEveryMs ?? 0;
+    const skipIfBodyMissing = options?.skipIfBodyMissing ?? true;
+    const autoPostOnBodyMutation = options?.autoPostOnBodyMutation ?? true;
+    const pathOptions: DynamicPathOptions = {
+      skipEmptyPlaceholder: options?.skipEmptyPlaceholder,
+    };
+    const stateKeyPrefix = `__${method.toLowerCase()}_state_`;
+
+    return function (target: object, propertyKey: string) {
+      if (!target) return;
+      setSubscribable(target);
+      const stateKey = `${stateKeyPrefix}${propertyKey}`;
+
+      (target as ConnectedComponent).__onConnected__((component) => {
+        const comp = component as Record<string, unknown>;
+        let state = comp[stateKey] as ApiSendState | undefined;
+        if (!state) {
+          state = {
+            cleanupWatchers: [],
+            requestGeneration: 0,
+            configPublisher: null,
+            configMutationHandler: null,
+            scopeWatchCleanup: null,
+            bodyPublisher: null,
+            bodyMutationHandler: null,
+            triggerPublisher: null,
+            triggerInvalidateHandler: null,
+            refetchTimeoutId: null,
+            refetchEveryMs,
+            skipIfBodyMissing,
+            autoPostOnBodyMutation,
+          };
+          comp[stateKey] = state;
+        }
+
+        state.cleanupWatchers.forEach((cleanup) => cleanup());
+        state.cleanupWatchers = [];
+        state.requestGeneration++;
+        state.refetchEveryMs = refetchEveryMs;
+        state.skipIfBodyMissing = skipIfBodyMissing;
+        state.autoPostOnBodyMutation = autoPostOnBodyMutation;
+        clearSendRefetch(state);
+
+        const scheduleRefetch = () => {
+          clearSendRefetch(state);
+          if (!state.refetchEveryMs || state.refetchEveryMs <= 0) return;
+          state.refetchTimeoutId = setTimeout(() => {
+            state.refetchTimeoutId = null;
+            runSend();
+          }, state.refetchEveryMs);
+        };
+
+        const runSend = () => {
+          const resolution = isDynamicPath
+            ? resolveDynamicPath(component, pathTemplate, pathOptions)
+            : { ready: true, path: pathTemplate };
+          if (!resolution.ready || !resolution.path) {
+            comp[propertyKey] = undefined;
+            scheduleRefetch();
+            return;
+          }
+
+          const bodyResolution = resolveDynamicPath(
+            component,
+            bodyKeyPath,
+            pathOptions,
+          );
+          if (!bodyResolution.ready || !bodyResolution.path) {
+            comp[propertyKey] = undefined;
+            scheduleRefetch();
+            return;
+          }
+
+          const bodyPublisher = getPublisherFromPath(bodyResolution.path);
+          const body = readBodyFromPublisher(bodyPublisher);
+          if (
+            state.skipIfBodyMissing &&
+            (body === null || body === undefined)
+          ) {
+            scheduleRefetch();
+            return;
+          }
+
+          let config: APIConfiguration | null = null;
+          if (usesPublisherConfig && configurationKeyPath) {
+            const configRes = resolveDynamicPath(
+              component,
+              configurationKeyPath,
+              pathOptions,
+            );
+            if (!configRes.ready || !configRes.path) {
+              comp[propertyKey] = undefined;
+              scheduleRefetch();
+              return;
+            }
+            const configPublisher = getPublisherFromPath(configRes.path);
+            config = readApiConfigurationFromPublisher(configPublisher);
+          } else {
+            config = resolveScopedConfiguration(component);
+          }
+
+          if (!isScopedConfigurationReady(config)) {
+            if (!usesPublisherConfig && !state.scopeWatchCleanup) {
+              const scopeWatch = watchScopedConfiguration(component, runSend);
+              state.scopeWatchCleanup = scopeWatch;
+              state.cleanupWatchers.push(() => {
+                scopeWatch();
+                state.scopeWatchCleanup = null;
+              });
+            }
+            scheduleRefetch();
+            return;
+          }
+
+          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();
+            },
+          );
+        };
+
+        const scheduleSend = createAnimationFrameCoalescedRunner(runSend);
+
+        const rebindBodyPublisher = () => {
+          detachBodyPublisher(state);
+          if (!state.autoPostOnBodyMutation) {
+            return;
+          }
+          const bodyResolution = resolveDynamicPath(
+            component,
+            bodyKeyPath,
+            pathOptions,
+          );
+          if (!bodyResolution.ready || !bodyResolution.path) {
+            return;
+          }
+          const publisher = getPublisherFromPath(bodyResolution.path);
+          if (!publisher) return;
+          const mutationHandler = () => scheduleSend();
+          publisher.onInternalMutation(mutationHandler);
+          state.bodyPublisher = publisher;
+          state.bodyMutationHandler = mutationHandler;
+        };
+
+        const rebindTriggerPublisher = () => {
+          detachTriggerPublisher(state);
+          if (!triggerKeyPath) return;
+          const triggerResolution = resolveDynamicPath(
+            component,
+            triggerKeyPath,
+            pathOptions,
+          );
+          if (!triggerResolution.ready || !triggerResolution.path) {
+            return;
+          }
+          const publisher = getPublisherFromPath(triggerResolution.path);
+          if (!publisher) return;
+          const invalidateHandler = () => scheduleSend();
+          publisher.onInvalidate(invalidateHandler);
+          state.triggerPublisher = publisher;
+          state.triggerInvalidateHandler = invalidateHandler;
+        };
+
+        const rebindPublisherConfig = () => {
+          if (!usesPublisherConfig || !configurationKeyPath) return;
+          detachConfigPublisher(state);
+          const configRes = resolveDynamicPath(
+            component,
+            configurationKeyPath,
+            pathOptions,
+          );
+          if (!configRes.ready || !configRes.path) {
+            comp[propertyKey] = undefined;
+            return;
+          }
+          const publisher = getPublisherFromPath(configRes.path);
+          if (!publisher) {
+            comp[propertyKey] = undefined;
+            return;
+          }
+          const mutationHandler = () => scheduleSend();
+          publisher.onInternalMutation(mutationHandler);
+          state.configPublisher = publisher;
+          state.configMutationHandler = mutationHandler;
+        };
+
+        const rebindAll = () => {
+          rebindBodyPublisher();
+          rebindTriggerPublisher();
+          rebindPublisherConfig();
+          if (state.autoPostOnBodyMutation) {
+            scheduleSend();
+          }
+        };
+
+        if (
+          usesPublisherConfig ||
+          bodyKeyDynamicDependencies.length ||
+          triggerKeyDynamicDependencies.length
+        ) {
+          for (const dependency of mergedDynamicDependencies) {
+            const unsubscribe = observeDynamicProperty(
+              getDynamicWatchKeys.watcherStore,
+              getDynamicWatchKeys.hooked,
+              component,
+              dependency,
+              () => rebindAll(),
+            );
+            state.cleanupWatchers.push(unsubscribe);
+          }
+          rebindAll();
+        } else {
+          const startScopedSend = () => {
+            if (isDynamicPath) {
+              for (const dependency of endpointDynamicDependencies) {
+                const unsubscribe = observeDynamicProperty(
+                  getDynamicWatchKeys.watcherStore,
+                  getDynamicWatchKeys.hooked,
+                  component,
+                  dependency,
+                  () => scheduleSend(),
+                );
+                state.cleanupWatchers.push(unsubscribe);
+              }
+            }
+            rebindBodyPublisher();
+            rebindTriggerPublisher();
+            if (state.autoPostOnBodyMutation) {
+              scheduleSend();
+            }
+          };
+          state.cleanupWatchers.push(
+            scheduleAfterHostReady(component, startScopedSend),
+          );
+        }
+      });
+
+      (target as ConnectedComponent).__onDisconnected__((component) => {
+        const comp = component as Record<string, unknown>;
+        const state = comp[stateKey] as ApiSendState | undefined;
+        if (!state) return;
+        detachConfigPublisher(state);
+        detachBodyPublisher(state);
+        detachTriggerPublisher(state);
+        clearSendRefetch(state);
+        state.cleanupWatchers.forEach((cleanup) => cleanup());
+        state.cleanupWatchers = [];
+        state.requestGeneration++;
+        comp[propertyKey] = undefined;
+      });
+    };
+  };
+}
+
+/**
+ * Décorateur **`@post`** : envoie des données via `API.postDetailed` et assigne un
+ * `ApiResult<T>` (`request`, `response`, `result` typé `T`).
+ *
+ * Le body est lu depuis un `DataProviderKey` (mutations et assignations relancent le POST).
+ *
+ * @example
+ * @post(new Endpoint<SyncResult, { sessionId: string }>("sessions/${sessionId}/sync"), syncRequestKey)
+ * payload?: ApiResult<SyncResult>;
+ */
+export function post<T, B, Ue = any>(
+  endpoint: Endpoint<T, Ue>,
+  bodyKey: DataProviderKey<B>,
+): <K extends string>(
+  target: DataProviderKeyHost<Ue> & {
+    [P in K]?: ApiResult<T> | null | undefined;
+  },
+  propertyKey: K,
+) => void;
+export function post<T, B, Ue = any, Uk = any>(
+  endpoint: Endpoint<T, Ue>,
+  bodyKey: DataProviderKey<B>,
+  configurationKey: DataProviderKey<APIConfiguration, Uk>,
+): <K extends string>(
+  target: DataProviderKeyHost<Ue> &
+    DataProviderKeyHost<Uk> & {
+      [P in K]?: ApiResult<T> | null | undefined;
+    },
+  propertyKey: K,
+) => void;
+export function post<T, B, Ue = any, Uk = any>(
+  endpoint: Endpoint<T, Ue>,
+  bodyKey: DataProviderKey<B>,
+  options: PostOptions<Uk>,
+): <K extends string>(
+  target: DataProviderKeyHost<Ue> & {
+    [P in K]?: ApiResult<T> | null | undefined;
+  },
+  propertyKey: K,
+) => void;
+export function post<T, B, Ue = any, Uk = any, Ut = any>(
+  endpoint: Endpoint<T, Ue>,
+  bodyKey: DataProviderKey<B>,
+  configurationKey: DataProviderKey<APIConfiguration, Uk>,
+  options: PostOptions<Ut>,
+): <K extends string>(
+  target: DataProviderKeyHost<Ue> &
+    DataProviderKeyHost<Uk> & {
+      [P in K]?: ApiResult<T> | null | undefined;
+    },
+  propertyKey: K,
+) => void;
+export function post<T, B, Ue = any, Uk = any, Ut = any>(
+  endpoint: Endpoint<T, Ue>,
+  bodyKey: DataProviderKey<B>,
+  configurationKeyOrOptions?:
+    | DataProviderKey<APIConfiguration, Uk>
+    | PostOptions<Ut>,
+  maybeOptions?: PostOptions<Ut>,
+): <K extends string>(
+  target: object & { [P in K]?: ApiResult<T> | null | undefined },
+  propertyKey: K,
+) => void {
+  return createApiSendDecorator<T, B, Ue, Uk, Ut>("POST", (api, path, body) =>
+    api.postDetailed<T, B>(path, body as B),
+  )(endpoint, bodyKey, configurationKeyOrOptions, maybeOptions);
+}
+
+/** `@put` — même modèle que `@post` via `API.putDetailed`. */
+export function put<T, B, Ue = any>(
+  endpoint: Endpoint<T, Ue>,
+  bodyKey: DataProviderKey<B>,
+): <K extends string>(
+  target: DataProviderKeyHost<Ue> & {
+    [P in K]?: ApiResult<T> | null | undefined;
+  },
+  propertyKey: K,
+) => void;
+export function put<T, B, Ue = any, Uk = any>(
+  endpoint: Endpoint<T, Ue>,
+  bodyKey: DataProviderKey<B>,
+  configurationKey: DataProviderKey<APIConfiguration, Uk>,
+): <K extends string>(
+  target: DataProviderKeyHost<Ue> &
+    DataProviderKeyHost<Uk> & {
+      [P in K]?: ApiResult<T> | null | undefined;
+    },
+  propertyKey: K,
+) => void;
+export function put<T, B, Ue = any, Uk = any>(
+  endpoint: Endpoint<T, Ue>,
+  bodyKey: DataProviderKey<B>,
+  options: PutOptions<Uk>,
+): <K extends string>(
+  target: DataProviderKeyHost<Ue> & {
+    [P in K]?: ApiResult<T> | null | undefined;
+  },
+  propertyKey: K,
+) => void;
+export function put<T, B, Ue = any, Uk = any, Ut = any>(
+  endpoint: Endpoint<T, Ue>,
+  bodyKey: DataProviderKey<B>,
+  configurationKey: DataProviderKey<APIConfiguration, Uk>,
+  options: PutOptions<Ut>,
+): <K extends string>(
+  target: DataProviderKeyHost<Ue> &
+    DataProviderKeyHost<Uk> & {
+      [P in K]?: ApiResult<T> | null | undefined;
+    },
+  propertyKey: K,
+) => void;
+export function put<T, B, Ue = any, Uk = any, Ut = any>(
+  endpoint: Endpoint<T, Ue>,
+  bodyKey: DataProviderKey<B>,
+  configurationKeyOrOptions?:
+    | DataProviderKey<APIConfiguration, Uk>
+    | PutOptions<Ut>,
+  maybeOptions?: PutOptions<Ut>,
+): <K extends string>(
+  target: object & { [P in K]?: ApiResult<T> | null | undefined },
+  propertyKey: K,
+) => void {
+  return createApiSendDecorator<T, B, Ue, Uk, Ut>("PUT", (api, path, body) =>
+    api.putDetailed<T, B>(path, body as B),
+  )(endpoint, bodyKey, configurationKeyOrOptions, maybeOptions);
+}
+
+/** `@patch` — même modèle que `@post` via `API.patchDetailed`. */
+export function patch<T, B, Ue = any>(
+  endpoint: Endpoint<T, Ue>,
+  bodyKey: DataProviderKey<B>,
+): <K extends string>(
+  target: DataProviderKeyHost<Ue> & {
+    [P in K]?: ApiResult<T> | null | undefined;
+  },
+  propertyKey: K,
+) => void;
+export function patch<T, B, Ue = any, Uk = any>(
+  endpoint: Endpoint<T, Ue>,
+  bodyKey: DataProviderKey<B>,
+  configurationKey: DataProviderKey<APIConfiguration, Uk>,
+): <K extends string>(
+  target: DataProviderKeyHost<Ue> &
+    DataProviderKeyHost<Uk> & {
+      [P in K]?: ApiResult<T> | null | undefined;
+    },
+  propertyKey: K,
+) => void;
+export function patch<T, B, Ue = any, Uk = any>(
+  endpoint: Endpoint<T, Ue>,
+  bodyKey: DataProviderKey<B>,
+  options: PatchOptions<Uk>,
+): <K extends string>(
+  target: DataProviderKeyHost<Ue> & {
+    [P in K]?: ApiResult<T> | null | undefined;
+  },
+  propertyKey: K,
+) => void;
+export function patch<T, B, Ue = any, Uk = any, Ut = any>(
+  endpoint: Endpoint<T, Ue>,
+  bodyKey: DataProviderKey<B>,
+  configurationKey: DataProviderKey<APIConfiguration, Uk>,
+  options: PatchOptions<Ut>,
+): <K extends string>(
+  target: DataProviderKeyHost<Ue> &
+    DataProviderKeyHost<Uk> & {
+      [P in K]?: ApiResult<T> | null | undefined;
+    },
+  propertyKey: K,
+) => void;
+export function patch<T, B, Ue = any, Uk = any, Ut = any>(
+  endpoint: Endpoint<T, Ue>,
+  bodyKey: DataProviderKey<B>,
+  configurationKeyOrOptions?:
+    | DataProviderKey<APIConfiguration, Uk>
+    | PatchOptions<Ut>,
+  maybeOptions?: PatchOptions<Ut>,
+): <K extends string>(
+  target: object & { [P in K]?: ApiResult<T> | null | undefined },
+  propertyKey: K,
+) => void {
+  return createApiSendDecorator<T, B, Ue, Uk, Ut>("PATCH", (api, path, body) =>
+    api.patchDetailed<T, B>(path, body as B),
+  )(endpoint, bodyKey, configurationKeyOrOptions, maybeOptions);
+}