@supersoniks/concorde 4.9.9 → 4.9.91

package/src/core/decorators/api.ts

@@ -167,6 +167,142 @@ type TriggerPublisherBinding = {
   triggerInvalidateHandler: (() => void) | null;
 };
 
+type OperationBinding = {
+  component: object;
+  run: () => void;
+};
+
+/**
+ * Handle interne des décorateurs API.
+ *
+ * Le WeakMap cible l'instance connectée, pas la valeur de payload : une
+ * opération peut donc être relancée avant son premier résultat et reste
+ * indépendante d'une affectation manuelle de la propriété décorée.
+ */
+class ApiOperationController {
+  private readonly bindings = new WeakMap<object, Set<OperationBinding>>();
+
+  bind(component: object, run: () => void): () => void {
+    const binding: OperationBinding = { component, run };
+    let componentBindings = this.bindings.get(component);
+    if (!componentBindings) {
+      componentBindings = new Set();
+      this.bindings.set(component, componentBindings);
+    }
+    componentBindings.add(binding);
+
+    return () => {
+      const currentBindings = this.bindings.get(component);
+      if (!currentBindings) return;
+      currentBindings.delete(binding);
+      if (currentBindings.size === 0) {
+        this.bindings.delete(component);
+      }
+    };
+  }
+
+  run(component: object): void {
+    this.bindings.get(component)?.forEach(({ run }) => run());
+  }
+}
+
+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.
+     *
+     * 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.
+     *
+     * Disponible avec `post`, `put` et `patch`.
+     */
+    send(component: Host): void;
+  };
+
+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.
+   */
+  when?: "before" | "after";
+};
+
+type ApiMethod = (this: object, ...args: any[]) => unknown;
+
+function isPromiseLike(value: unknown): value is PromiseLike<unknown> {
+  return (
+    value !== null &&
+    (typeof value === "object" || typeof value === "function") &&
+    typeof (value as { then?: unknown }).then === "function"
+  );
+}
+
+function createApiMethodActionDecorator(
+  action: (component: object) => void,
+  options?: ApiMethodActionOptions,
+): MethodDecorator {
+  const when = options?.when ?? "after";
+
+  return (_target, _propertyKey, descriptor) => {
+    const original = descriptor.value as ApiMethod | undefined;
+    if (!original) return;
+
+    const wrapped = function (this: object, ...args: any[]) {
+      if (when === "before") {
+        action(this);
+        return original.apply(this, args);
+      }
+
+      const result = original.apply(this, args);
+      if (isPromiseLike(result)) {
+        return result.then((value) => {
+          action(this);
+          return value;
+        });
+      }
+
+      action(this);
+      return result;
+    };
+    descriptor.value = wrapped as unknown as typeof descriptor.value;
+  };
+}
+
+export function refetch<T, Host extends object = object>(
+  handle: GetDecoratorHandle<T, Host>,
+  options?: ApiMethodActionOptions,
+): MethodDecorator {
+  return createApiMethodActionDecorator(
+    (component) => handle.refetch(component as Host),
+    options,
+  );
+}
+
+export function send<T, Host extends object = object>(
+  handle: ApiSendDecoratorHandle<T, Host>,
+  options?: ApiMethodActionOptions,
+): MethodDecorator {
+  return createApiMethodActionDecorator(
+    (component) => handle.send(component as Host),
+    options,
+  );
+}
+
 type RefetchScheduleState = {
   refetchTimeoutId: ReturnType<typeof setTimeout> | null;
   refetchEveryMs: number;
@@ -175,6 +311,7 @@ type RefetchScheduleState = {
 type ApiGetState = TriggerPublisherBinding &
   RefetchScheduleState & {
     cleanupWatchers: Array<() => void>;
+    cleanupOperation: (() => void) | null;
     requestGeneration: number;
     configPublisher: DataProvider | null;
     configMutationHandler: (() => void) | null;
@@ -202,8 +339,12 @@ function detachConfigPublisher(state: ApiGetState): void {
  * `PublisherManager` sur le chemin résolu (même syntaxe dynamique que `@subscribe`).
  * Toute mutation interne du publisher (`onInternalMutation`) relance le GET.
  *
- * **Options** (`GetOptions`) : `triggerKey` — `PublisherManager.get(...).invalidate()` relance le GET ;
- * `refetchEveryMs` — polling automatique.
+ * Le décorateur retourné expose `refetch(component)` pour relancer le GET d'une
+ * instance connectée. Pour déclencher le refetch depuis un autre composant,
+ * utiliser `triggerKey` puis `PublisherManager.get(...).invalidate()`.
+ *
+ * **Options** (`GetOptions`) : `triggerKey` — signal de refetch externe ;
+ * `refetchEveryMs` — polling automatique (0 ou absent = désactivé).
  *
  * @example
  * @get(new Endpoint<User, { userId: string }>("users/${userId}"))
@@ -216,58 +357,48 @@ function detachConfigPublisher(state: ApiGetState): void {
  * payload?: ApiResult<Thing>;
  *
  * @example
+ * const usersGet = get(new Endpoint<User[]>("users"));
+ * @usersGet
+ * payload?: ApiResult<User[]>;
+ *
+ * refresh() {
+ *   usersGet.refetch(this);
+ * }
+ *
+ * @example
  * @get(usersEndpoint, { triggerKey: refreshUsersKey })
  * payload?: ApiResult<User[]>;
  * // PublisherManager.get("users.refresh").invalidate() → refetch
  */
 export function get<T, Ue = any>(
   endpoint: Endpoint<T, Ue>,
-): <K extends string>(
-  target: DataProviderKeyHost<Ue> & {
-    [P in K]?: ApiResult<T> | null | undefined;
-  },
-  propertyKey: K,
-) => void;
+): GetDecoratorHandle<T, DataProviderKeyHost<Ue>>;
 export function get<T, Ue = any, Uk = any>(
   endpoint: Endpoint<T, Ue>,
   configurationKey: DataProviderKey<APIConfiguration, Uk>,
-): <K extends string>(
-  target: DataProviderKeyHost<Ue> &
-    DataProviderKeyHost<Uk> & {
-      [P in K]?: ApiResult<T> | null | undefined;
-    },
-  propertyKey: K,
-) => void;
+): GetDecoratorHandle<
+  T,
+  DataProviderKeyHost<Ue> & DataProviderKeyHost<Uk>
+>;
 export function get<T, Ue = any, Uk = any>(
   endpoint: Endpoint<T, Ue>,
   options: GetOptions,
-): <K extends string>(
-  target: DataProviderKeyHost<Ue> & {
-    [P in K]?: ApiResult<T> | null | undefined;
-  },
-  propertyKey: K,
-) => void;
+): GetDecoratorHandle<T, DataProviderKeyHost<Ue>>;
 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;
+): 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,
   maybeOptions?: GetOptions,
-): <K extends string>(
-  target: object & { [P in K]?: ApiResult<T> | null | undefined },
-  propertyKey: K,
-) => void {
+): GetDecoratorHandle<T, object> {
   const pathTemplate = endpoint.path;
   const configurationKey = isGetOptions(configurationKeyOrOptions)
     ? undefined
@@ -297,8 +428,9 @@ export function get<T, Ue = any, Uk = any, _Ut = any>(
   const isDynamicPath = endpointDynamicDependencies.length > 0;
   const usesPublisherConfig = Boolean(configurationKeyPath);
   const refetchEveryMs = options?.refetchEveryMs ?? 0;
+  const operationController = new ApiOperationController();
 
-  return function (target: object, propertyKey: string) {
+  const decorator = function (target: object, propertyKey: string) {
     if (!target) return;
     setSubscribable(target);
     const stateKey = `__get_state_${propertyKey}`;
@@ -309,6 +441,7 @@ export function get<T, Ue = any, Uk = any, _Ut = any>(
       if (!state) {
         state = {
           cleanupWatchers: [],
+          cleanupOperation: null,
           requestGeneration: 0,
           configPublisher: null,
           configMutationHandler: null,
@@ -321,6 +454,8 @@ export function get<T, Ue = any, Uk = any, _Ut = any>(
         comp[stateKey] = state;
       }
 
+      state.cleanupOperation?.();
+      state.cleanupOperation = null;
       state.cleanupWatchers.forEach((cleanup) => cleanup());
       state.cleanupWatchers = [];
       state.requestGeneration++;
@@ -386,6 +521,10 @@ export function get<T, Ue = any, Uk = any, _Ut = any>(
       };
 
       const scheduleFetch = createAnimationFrameCoalescedRunner(runFetch);
+      state.cleanupOperation = operationController.bind(
+        component,
+        scheduleFetch,
+      );
 
       const rebindTriggerPublisher = () => {
         detachTriggerPublisher(state);
@@ -476,6 +615,8 @@ export function get<T, Ue = any, Uk = any, _Ut = any>(
       const comp = component as Record<string, unknown>;
       const state = comp[stateKey] as ApiGetState | undefined;
       if (!state) return;
+      state.cleanupOperation?.();
+      state.cleanupOperation = null;
       detachConfigPublisher(state);
       detachTriggerPublisher(state);
       clearRefetch(state);
@@ -484,27 +625,36 @@ export function get<T, Ue = any, Uk = any, _Ut = any>(
       state.requestGeneration++;
       comp[propertyKey] = undefined;
     });
+  } as GetDecoratorHandle<T, object>;
+
+  decorator.refetch = (component: object) => {
+    operationController.run(component);
   };
+
+  return decorator;
 }
 
 export type GetOptions<Uk = any> = DynamicPathOptions & {
-  /** Intervalle de refetch automatique (ms). 0 ou absent = pas de polling. */
+  /** Intervalle de refetch automatique (ms). 0 ou absent = désactivé. */
   refetchEveryMs?: number;
-  /** Publisher dont `invalidate()` relance le GET. */
+  /** Publisher-signal dont `invalidate()` relance le GET. */
   triggerKey?: DataProviderKey<unknown, Uk>;
 };
 
 export type ApiSendOptions<Uk = any> = DynamicPathOptions & {
-  /** Intervalle de renvoi automatique (ms). 0 ou absent = pas de polling. */
+  /**
+   * Intervalle de renvoi automatique (ms).
+   * 0 ou absent = désactivé ; attention aux effets de bord de l'opération.
+   */
   refetchEveryMs?: number;
-  /** Ne pas envoyer si le body publisher est null/undefined (défaut: true). */
+  /** Ignore l'envoi si le body vaut 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()`.
+   * Relance l'envoi quand le body publisher mute (défaut : true).
+   * `false` : le body est lu au moment de `send()` ou `triggerKey.invalidate()`.
    */
   autoPostOnBodyMutation?: boolean;
-  /** Publisher dont `invalidate()` relance l'envoi (relit le body courant). */
+  /** Publisher-signal dont `invalidate()` relance l'envoi avec le body courant. */
   triggerKey?: DataProviderKey<unknown, Uk>;
 };
 
@@ -591,10 +741,7 @@ function createApiSendDecorator<T, B, Ue = any, Uk = any, Ut = any>(
       | DataProviderKey<APIConfiguration, Uk>
       | ApiSendOptions<Ut>,
     maybeOptions?: ApiSendOptions<Ut>,
-  ): <K extends string>(
-    target: object & { [P in K]?: ApiResult<T> | null | undefined },
-    propertyKey: K,
-  ) => void {
+  ): ApiSendDecoratorHandle<T, object> {
     const pathTemplate = endpoint.path;
     const bodyKeyPath = bodyKey.path;
     const configurationKey = isApiSendOptions(configurationKeyOrOptions)
@@ -631,8 +778,9 @@ function createApiSendDecorator<T, B, Ue = any, Uk = any, Ut = any>(
       skipEmptyPlaceholder: options?.skipEmptyPlaceholder,
     };
     const stateKeyPrefix = `__${method.toLowerCase()}_state_`;
+    const operationController = new ApiOperationController();
 
-    return function (target: object, propertyKey: string) {
+    const decorator = function (target: object, propertyKey: string) {
       if (!target) return;
       setSubscribable(target);
       const stateKey = `${stateKeyPrefix}${propertyKey}`;
@@ -643,6 +791,7 @@ function createApiSendDecorator<T, B, Ue = any, Uk = any, Ut = any>(
         if (!state) {
           state = {
             cleanupWatchers: [],
+            cleanupOperation: null,
             requestGeneration: 0,
             configPublisher: null,
             configMutationHandler: null,
@@ -659,6 +808,8 @@ function createApiSendDecorator<T, B, Ue = any, Uk = any, Ut = any>(
           comp[stateKey] = state;
         }
 
+        state.cleanupOperation?.();
+        state.cleanupOperation = null;
         state.cleanupWatchers.forEach((cleanup) => cleanup());
         state.cleanupWatchers = [];
         state.requestGeneration++;
@@ -750,6 +901,10 @@ function createApiSendDecorator<T, B, Ue = any, Uk = any, Ut = any>(
         };
 
         const scheduleSend = createAnimationFrameCoalescedRunner(runSend);
+        state.cleanupOperation = operationController.bind(
+          component,
+          scheduleSend,
+        );
 
         const rebindBodyPublisher = () => {
           detachBodyPublisher(state);
@@ -869,6 +1024,8 @@ function createApiSendDecorator<T, B, Ue = any, Uk = any, Ut = any>(
         const comp = component as Record<string, unknown>;
         const state = comp[stateKey] as ApiSendState | undefined;
         if (!state) return;
+        state.cleanupOperation?.();
+        state.cleanupOperation = null;
         detachConfigPublisher(state);
         detachBodyPublisher(state);
         detachTriggerPublisher(state);
@@ -878,7 +1035,13 @@ function createApiSendDecorator<T, B, Ue = any, Uk = any, Ut = any>(
         state.requestGeneration++;
         comp[propertyKey] = undefined;
       });
+    } as ApiSendDecoratorHandle<T, object>;
+
+    decorator.send = (component: object) => {
+      operationController.run(component);
     };
+
+    return decorator;
   };
 }
 
@@ -886,54 +1049,46 @@ function createApiSendDecorator<T, B, Ue = any, Uk = any, Ut = any>(
  * 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).
+ * Le body est lu depuis un `DataProviderKey`. Par défaut, une mutation du body
+ * relance le POST ; `send(component)` permet de le relancer explicitement.
  *
  * @example
  * @post(new Endpoint<SyncResult, { sessionId: string }>("sessions/${sessionId}/sync"), syncRequestKey)
  * payload?: ApiResult<SyncResult>;
+ *
+ * @example
+ * const save = post(new Endpoint<User>("users"), userRequestKey);
+ * @save
+ * payload?: ApiResult<User>;
+ * // Dans un handler du composant :
+ * save.send(this);
  */
 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;
+): ApiSendDecoratorHandle<T, DataProviderKeyHost<Ue>>;
 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;
+): ApiSendDecoratorHandle<
+  T,
+  DataProviderKeyHost<Ue> & DataProviderKeyHost<Uk>
+>;
 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;
+): ApiSendDecoratorHandle<T, DataProviderKeyHost<Ue>>;
 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;
+): ApiSendDecoratorHandle<
+  T,
+  DataProviderKeyHost<Ue> & DataProviderKeyHost<Uk>
+>;
 export function post<T, B, Ue = any, Uk = any, Ut = any>(
   endpoint: Endpoint<T, Ue>,
   bodyKey: DataProviderKey<B>,
@@ -941,58 +1096,39 @@ export function post<T, B, Ue = any, Uk = any, Ut = any>(
     | DataProviderKey<APIConfiguration, Uk>
     | PostOptions<Ut>,
   maybeOptions?: PostOptions<Ut>,
-): <K extends string>(
-  target: object & { [P in K]?: ApiResult<T> | null | undefined },
-  propertyKey: K,
-) => void {
+): ApiSendDecoratorHandle<T, object> {
   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`. */
+/** `@put` — même modèle que `@post`, via `API.putDetailed` et `send()`. */
 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;
+): ApiSendDecoratorHandle<T, DataProviderKeyHost<Ue>>;
 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;
+): ApiSendDecoratorHandle<
+  T,
+  DataProviderKeyHost<Ue> & DataProviderKeyHost<Uk>
+>;
 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;
+): ApiSendDecoratorHandle<T, DataProviderKeyHost<Ue>>;
 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;
+): ApiSendDecoratorHandle<
+  T,
+  DataProviderKeyHost<Ue> & DataProviderKeyHost<Uk>
+>;
 export function put<T, B, Ue = any, Uk = any, Ut = any>(
   endpoint: Endpoint<T, Ue>,
   bodyKey: DataProviderKey<B>,
@@ -1000,58 +1136,39 @@ export function put<T, B, Ue = any, Uk = any, Ut = any>(
     | DataProviderKey<APIConfiguration, Uk>
     | PutOptions<Ut>,
   maybeOptions?: PutOptions<Ut>,
-): <K extends string>(
-  target: object & { [P in K]?: ApiResult<T> | null | undefined },
-  propertyKey: K,
-) => void {
+): ApiSendDecoratorHandle<T, object> {
   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`. */
+/** `@patch` — même modèle que `@post`, via `API.patchDetailed` et `send()`. */
 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;
+): ApiSendDecoratorHandle<T, DataProviderKeyHost<Ue>>;
 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;
+): ApiSendDecoratorHandle<
+  T,
+  DataProviderKeyHost<Ue> & DataProviderKeyHost<Uk>
+>;
 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;
+): ApiSendDecoratorHandle<T, DataProviderKeyHost<Ue>>;
 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;
+): ApiSendDecoratorHandle<
+  T,
+  DataProviderKeyHost<Ue> & DataProviderKeyHost<Uk>
+>;
 export function patch<T, B, Ue = any, Uk = any, Ut = any>(
   endpoint: Endpoint<T, Ue>,
   bodyKey: DataProviderKey<B>,
@@ -1059,10 +1176,7 @@ export function patch<T, B, Ue = any, Uk = any, Ut = any>(
     | DataProviderKey<APIConfiguration, Uk>
     | PatchOptions<Ut>,
   maybeOptions?: PatchOptions<Ut>,
-): <K extends string>(
-  target: object & { [P in K]?: ApiResult<T> | null | undefined },
-  propertyKey: K,
-) => void {
+): ApiSendDecoratorHandle<T, object> {
   return createApiSendDecorator<T, B, Ue, Uk, Ut>("PATCH", (api, path, body) =>
     api.patchDetailed<T, B>(path, body as B),
   )(endpoint, bodyKey, configurationKeyOrOptions, maybeOptions);

package/src/decorators.ts

@@ -19,6 +19,8 @@ export const get = api.get;
 export const post = api.post;
 export const put = api.put;
 export const patch = api.patch;
+export const refetch = api.refetch;
+export const send = api.send;
 export {
   DataProviderKey,
   type DataProviderKeyHost,
@@ -27,6 +29,9 @@ export { Endpoint };
 export type { ApiResult, ApiGetResult } from "./core/utils/api";
 export type {
   ApiSendOptions,
+  ApiSendDecoratorHandle,
+  ApiMethodActionOptions,
+  GetDecoratorHandle,
   GetOptions,
   PostOptions,
   PutOptions,
@@ -57,4 +62,6 @@ window["concorde-decorator-subscriber"] = {
   post: api.post,
   put: api.put,
   patch: api.patch,
+  refetch: api.refetch,
+  send: api.send,
 };