ebely 0.0.5 → 0.0.7

package/dist/index.d.ts

@@ -110,6 +110,24 @@ type AfterHookArgs<Ctx, Body = unknown, ResBody = unknown> = {
 type BeforeHook<Ctx, Body = unknown> = (args: BeforeHookArgs<Ctx, Body>) => void | Promise<void>;
 /** `after`-хук: вызывается ПОСЛЕ ответа; `response` — только на чтение. */
 type AfterHook<Ctx, Body = unknown, ResBody = unknown> = (args: AfterHookArgs<Ctx, Body, ResBody>) => void | Promise<void>;
+/**
+ * `retry`-хук: вызывается ПОСЛЕ ответа (и после всех `after`-хуков) и
+ * РЕШАЕТ, нужно ли переиграть тот же запрос. Возврат `true` → ebely
+ * выполняет запрос заново (с нуля: снова прогоняет `before`-хуки и шлёт
+ * fetch), поэтому правки, сделанные внутри хука (напр. свежий токен в
+ * `ctx`), автоматически подхватятся повторным `before`. Любой
+ * не-истинный возврат (`false` / `undefined`) → ретрая нет, отдаём ответ
+ * как есть.
+ *
+ * Аргумент — тот же, что у `after` (`request` / `response` / `ctx`):
+ * `response` тут на чтение (его смотрят, чтобы решить про ретрай), а
+ * подготовку к повтору (refresh токена и т.п.) хук делает через `ctx`.
+ *
+ * Число повторов ограничено ядром (`EbelyConfig.maxRetries`, по
+ * умолчанию 3) — даже если хук упрямо возвращает `true`, бесконечного
+ * цикла не будет.
+ */
+type RetryHook<Ctx, Body = unknown, ResBody = unknown> = (args: AfterHookArgs<Ctx, Body, ResBody>) => boolean | void | Promise<boolean | void>;
 /**
  * Регистратор хуков, который пользователь передаёт в конфиг одной
  * переменной (`EbelyConfig.hooks`). Точную типизированную форму аргумента
@@ -137,6 +155,9 @@ type HooksRegistrar = (registrar: any) => void;
 declare class HookRegistry {
     private beforeMap;
     private afterMap;
+    private globalBeforeHooks;
+    private globalAfterHooks;
+    private globalRetryHooks;
     /** Зарегистрировать `before`-хук на ключ `"<группа>.<метод>"`. */
     before(args: {
         key: string;
@@ -147,19 +168,52 @@ declare class HookRegistry {
         key: string;
         fn: AfterHook<any>;
     }): void;
-    /** Прогнать все `before`-хуки ключа по очереди (await на async). */
+    /** Зарегистрировать ГЛОБАЛЬНЫЙ `before`-хук (на все операции). */
+    globalBefore(args: {
+        fn: BeforeHook<any>;
+    }): void;
+    /** Зарегистрировать ГЛОБАЛЬНЫЙ `after`-хук (на все операции). */
+    globalAfter(args: {
+        fn: AfterHook<any>;
+    }): void;
+    /** Зарегистрировать ГЛОБАЛЬНЫЙ `retry`-хук (решает про повтор запроса). */
+    globalRetry(args: {
+        fn: RetryHook<any>;
+    }): void;
+    /**
+     * Прогнать `before`-хуки по очереди (await на async): сначала глобальные,
+     * затем поименные для ключа — так общая подготовка (напр. заголовок
+     * авторизации) ложится раньше, а точечный хук может её переопределить.
+     */
     runBefore(args: {
         key: string;
         request: HookRequest;
         ctx: unknown;
     }): Promise<void>;
-    /** Прогнать все `after`-хуки ключа по очереди (await на async). */
+    /**
+     * Прогнать `after`-хуки по очереди (await на async): сначала поименные
+     * для ключа, затем глобальные — так глобальный «оборачивает» точечные
+     * (видит итоговый эффект, удобно для логирования/обработки статуса).
+     */
     runAfter(args: {
         key: string;
         request: HookRequest;
         response: HookResponse;
         ctx: unknown;
     }): Promise<void>;
+    /**
+     * Спросить retry-хуки, нужно ли переиграть запрос. Прогон по очереди
+     * регистрации; ПЕРВЫЙ хук, вернувший истину, выигрывает (он уже сделал
+     * подготовку — напр. refresh — поэтому остальные не дёргаем). Если ни
+     * один не вернул истину — `false` (повтора нет). Цикл и лимит повторов
+     * — на стороне вызывающего (сгенерированный `request`).
+     */
+    runRetry(args: {
+        key: string;
+        request: HookRequest;
+        response: HookResponse;
+        ctx: unknown;
+    }): Promise<boolean>;
 }
 
 /**
@@ -218,6 +272,16 @@ type EbelyConfig = {
      * @default 'test'
      */
     mode?: ClientMode;
+    /**
+     * Максимальное число ПОВТОРОВ запроса, которые ebely сделает, если
+     * глобальный `retry`-хук (`h.globalRetry`) вернул `true`. Это потолок
+     * на повторы СВЕРХ первой попытки: при `maxRetries: 3` запрос уйдёт
+     * максимум 4 раза. Защита от бесконечного цикла, если хук упрямо просит
+     * повтор (напр. сервер стабильно отвечает 401). Без `globalRetry`-хуков
+     * не влияет ни на что.
+     * @default 3
+     */
+    maxRetries?: number;
     /**
      * Регистратор хуков `before` / `after`. Объявляется в ОТДЕЛЬНОМ
      * типизированном файле (тип `Hooks` экспортирует сгенерированный
@@ -270,4 +334,4 @@ declare function generateClient(args: EbelyConfig): Promise<{
     operations: number;
 }>;
 
-export { AfterHook, AfterHookArgs, ApiResponse, BaseStore, BeforeHook, BeforeHookArgs, ClientMode, DeepPartial, EbelyAssertionError, EbelyConfig, HookRegistry, HookRequest, HookResponse, HooksRegistrar, SwaggerSource, generateClient };
+export { AfterHook, AfterHookArgs, ApiResponse, BaseStore, BeforeHook, BeforeHookArgs, ClientMode, DeepPartial, EbelyAssertionError, EbelyConfig, HookRegistry, HookRequest, HookResponse, HooksRegistrar, RetryHook, SwaggerSource, generateClient };

package/dist/index.js

@@ -163,6 +163,15 @@ var ApiResponse = class {
 var HookRegistry = class {
   beforeMap = /* @__PURE__ */ new Map();
   afterMap = /* @__PURE__ */ new Map();
+  // Глобальные хуки — срабатывают на КАЖДУЮ операцию (вне зависимости от
+  // ключа). Удобны для сквозных задач: подстановка `Authorization` из
+  // `ctx` во все запросы, логирование, обработка 401 и т.п.
+  globalBeforeHooks = [];
+  globalAfterHooks = [];
+  // Глобальные retry-хуки — решают, переигрывать ли запрос (напр. на 401
+  // сходить за refresh и вернуть `true`). Цикл повторов и его лимит живут
+  // в сгенерированном `request` (см. render.ts) — сам реестр сети не знает.
+  globalRetryHooks = [];
   /** Зарегистрировать `before`-хук на ключ `"<группа>.<метод>"`. */
   before(args) {
     const list = this.beforeMap.get(args.key) ?? [];
@@ -175,18 +184,59 @@ var HookRegistry = class {
     list.push(args.fn);
     this.afterMap.set(args.key, list);
   }
-  /** Прогнать все `before`-хуки ключа по очереди (await на async). */
+  /** Зарегистрировать ГЛОБАЛЬНЫЙ `before`-хук (на все операции). */
+  globalBefore(args) {
+    this.globalBeforeHooks.push(args.fn);
+  }
+  /** Зарегистрировать ГЛОБАЛЬНЫЙ `after`-хук (на все операции). */
+  globalAfter(args) {
+    this.globalAfterHooks.push(args.fn);
+  }
+  /** Зарегистрировать ГЛОБАЛЬНЫЙ `retry`-хук (решает про повтор запроса). */
+  globalRetry(args) {
+    this.globalRetryHooks.push(args.fn);
+  }
+  /**
+   * Прогнать `before`-хуки по очереди (await на async): сначала глобальные,
+   * затем поименные для ключа — так общая подготовка (напр. заголовок
+   * авторизации) ложится раньше, а точечный хук может её переопределить.
+   */
   async runBefore(args) {
-    for (const fn of this.beforeMap.get(args.key) ?? []) {
+    const hooks = [...this.globalBeforeHooks, ...this.beforeMap.get(args.key) ?? []];
+    for (const fn of hooks) {
       await fn({ request: args.request, ctx: args.ctx });
     }
   }
-  /** Прогнать все `after`-хуки ключа по очереди (await на async). */
+  /**
+   * Прогнать `after`-хуки по очереди (await на async): сначала поименные
+   * для ключа, затем глобальные — так глобальный «оборачивает» точечные
+   * (видит итоговый эффект, удобно для логирования/обработки статуса).
+   */
   async runAfter(args) {
-    for (const fn of this.afterMap.get(args.key) ?? []) {
+    const hooks = [...this.afterMap.get(args.key) ?? [], ...this.globalAfterHooks];
+    for (const fn of hooks) {
       await fn({ request: args.request, response: args.response, ctx: args.ctx });
     }
   }
+  /**
+   * Спросить retry-хуки, нужно ли переиграть запрос. Прогон по очереди
+   * регистрации; ПЕРВЫЙ хук, вернувший истину, выигрывает (он уже сделал
+   * подготовку — напр. refresh — поэтому остальные не дёргаем). Если ни
+   * один не вернул истину — `false` (повтора нет). Цикл и лимит повторов
+   * — на стороне вызывающего (сгенерированный `request`).
+   */
+  async runRetry(args) {
+    for (const fn of this.globalRetryHooks) {
+      const decision = await fn({
+        request: args.request,
+        response: args.response,
+        ctx: args.ctx
+      });
+      if (decision)
+        return true;
+    }
+    return false;
+  }
 };
 
 // src/generate-client.ts
@@ -314,8 +364,38 @@ function collectOperations(args) {
       });
     }
   }
+  dedupeNames({ operations });
   return operations;
 }
+function prefixMethod(args) {
+  const { method, name } = args;
+  return method + name.charAt(0).toUpperCase() + name.slice(1);
+}
+function dedupeNames(args) {
+  const { operations } = args;
+  const counts = /* @__PURE__ */ new Map();
+  for (const op of operations) {
+    const byName = counts.get(op.group) ?? /* @__PURE__ */ new Map();
+    byName.set(op.name, (byName.get(op.name) ?? 0) + 1);
+    counts.set(op.group, byName);
+  }
+  const taken = /* @__PURE__ */ new Map();
+  const claim = (group, name) => {
+    const used = taken.get(group) ?? /* @__PURE__ */ new Set();
+    let candidate = name;
+    let i = 2;
+    while (used.has(candidate))
+      candidate = `${name}${i++}`;
+    used.add(candidate);
+    taken.set(group, used);
+    return candidate;
+  };
+  for (const op of operations) {
+    const collides = (counts.get(op.group)?.get(op.name) ?? 0) > 1;
+    const base = collides ? prefixMethod({ method: op.method, name: op.name }) : op.name;
+    op.name = claim(op.group, base);
+  }
+}
 
 // src/generator/render.ts
 function buildInputType(op) {
@@ -380,7 +460,7 @@ function renderImports(args) {
   const { mode, userStoreImport, configImport } = args;
   const values = mode === "frontend" ? "BaseStore, HookRegistry" : "BaseStore, ApiResponse, HookRegistry";
   return `import { ${values} } from ${JSON.stringify(userStoreImport)}
-import type { BeforeHook, AfterHook } from ${JSON.stringify(userStoreImport)}
+import type { BeforeHook, AfterHook, RetryHook } from ${JSON.stringify(userStoreImport)}
 import { ebely } from ${JSON.stringify(configImport)}`;
 }
 function renderRequestTail(mode) {
@@ -439,7 +519,11 @@ function renderHookTreeType(groups) {
 ${leaves.join("\n")}
     }`;
   });
+  const global = `    globalBefore(fn: BeforeHook<Store>): void
+    globalAfter(fn: AfterHook<Store>): void
+    globalRetry(fn: RetryHook<Store>): void`;
   return `type EbelyHookTree<Store extends BaseStore> = {
+${global}
 ${blocks.join("\n")}
 }`;
 }
@@ -459,6 +543,9 @@ ${leaves.join("\n")}
   return `  private buildHookTree(): EbelyHookTree<Store> {
     const r = this.hookRegistry
     return {
+      globalBefore: (fn: BeforeHook<Store>) => r.globalBefore({ fn }),
+      globalAfter: (fn: AfterHook<Store>) => r.globalAfter({ fn }),
+      globalRetry: (fn: RetryHook<Store>) => r.globalRetry({ fn }),
 ${blocks.join("\n")}
     } as unknown as EbelyHookTree<Store>
   }`;
@@ -483,6 +570,7 @@ function renderClient(args) {
   const basePath = spec.servers?.[0]?.url ?? "";
   const groups = groupOperations(operations);
   const tail = renderRequestTail(mode);
+  const tailRet = tail.ret.split("\n").map((l) => l.trim() ? `  ${l}` : l).join("\n");
   return `// AUTO-GENERATED by ebely (generateClient) \u2014 \u041D\u0415 \u0440\u0435\u0434\u0430\u043A\u0442\u0438\u0440\u043E\u0432\u0430\u0442\u044C \u0432\u0440\u0443\u0447\u043D\u0443\u044E.
 // \u0418\u0441\u0442\u043E\u0447\u043D\u0438\u043A: ${spec.info?.title ?? "OpenAPI spec"} v${spec.info?.version ?? "?"}
 // \u0420\u0435\u0436\u0438\u043C \u043A\u043B\u0438\u0435\u043D\u0442\u0430: ${mode}
@@ -588,59 +676,84 @@ ${renderHookTreeBuilder(groups)}
     const baseUrl = this.baseUrl()
     const registry = this.hookRegistry
     const { headers: baseHeaders, store } = cfg
+    // \u041F\u043E\u0442\u043E\u043B\u043E\u043A \u041F\u041E\u0412\u0422\u041E\u0420\u041E\u0412 (\u0441\u0432\u0435\u0440\u0445 \u043F\u0435\u0440\u0432\u043E\u0439 \u043F\u043E\u043F\u044B\u0442\u043A\u0438) \u0434\u043B\u044F globalRetry-\u0445\u0443\u043A\u043E\u0432 \u2014
+    // \u0437\u0430\u0449\u0438\u0442\u0430 \u043E\u0442 \u0431\u0435\u0441\u043A\u043E\u043D\u0435\u0447\u043D\u043E\u0433\u043E \u0446\u0438\u043A\u043B\u0430, \u0435\u0441\u043B\u0438 \u0445\u0443\u043A \u0443\u043F\u0440\u044F\u043C\u043E \u043F\u0440\u043E\u0441\u0438\u0442 \u043F\u043E\u0432\u0442\u043E\u0440.
+    const maxRetries = (ebely as { maxRetries?: number }).maxRetries ?? 3
 
     return async (req): Promise<${tail.returnType}> => {
       const { method, path, opKey, input } = req
 
-      const hookReq = {
-        method,
-        path,
-        pathParams: { ...(input?.path ?? {}) },
-        query: { ...(input?.query ?? {}) },
-        body: input?.body,
-        headers: { ...baseHeaders },
-      }
-      await registry.runBefore({ key: opKey, request: hookReq, ctx: store })
-
-      let resolvedPath = path
-      for (const [k, v] of Object.entries(hookReq.pathParams)) {
-        resolvedPath = resolvedPath.replace(
-          \`{\${k}}\`,
-          encodeURIComponent(String(v)),
-        )
+      // Retry-\u0446\u0438\u043A\u043B: \u043A\u0430\u0436\u0434\u0443\u044E \u043F\u043E\u043F\u044B\u0442\u043A\u0443 hookReq \u0441\u043E\u0431\u0438\u0440\u0430\u0435\u0442\u0441\u044F \u0417\u0410\u041D\u041E\u0412\u041E \u0438 \u0437\u0430\u043D\u043E\u0432\u043E
+      // \u043F\u0440\u043E\u0433\u043E\u043D\u044F\u044E\u0442\u0441\u044F before-\u0445\u0443\u043A\u0438, \u043F\u043E\u044D\u0442\u043E\u043C\u0443 \u043F\u0440\u0430\u0432\u043A\u0438 \u0438\u0437 retry-\u0445\u0443\u043A\u0430 (\u043D\u0430\u043F\u0440.
+      // \u0441\u0432\u0435\u0436\u0438\u0439 \u0442\u043E\u043A\u0435\u043D \u0432 ctx) \u043F\u043E\u0434\u0445\u0432\u0430\u0442\u044B\u0432\u0430\u044E\u0442\u0441\u044F \u043F\u043E\u0432\u0442\u043E\u0440\u043D\u044B\u043C before. \`for (;;)\`
+      // \u043A\u0440\u0443\u0442\u0438\u0442\u0441\u044F, \u043F\u043E\u043A\u0430 \u043D\u0435 \u0441\u0440\u0430\u0431\u043E\u0442\u0430\u0435\u0442 return/throw \u0432 \u0445\u0432\u043E\u0441\u0442\u0435 \u0438\u043B\u0438 \`continue\`.
+      let attempt = 0
+      for (;;) {
+        const hookReq = {
+          method,
+          path,
+          pathParams: { ...(input?.path ?? {}) },
+          query: { ...(input?.query ?? {}) },
+          body: input?.body,
+          headers: { ...baseHeaders },
+        }
+        await registry.runBefore({ key: opKey, request: hookReq, ctx: store })
+
+        let resolvedPath = path
+        for (const [k, v] of Object.entries(hookReq.pathParams)) {
+          resolvedPath = resolvedPath.replace(
+            \`{\${k}}\`,
+            encodeURIComponent(String(v)),
+          )
+        }
+
+        const url = new URL(baseUrl + resolvedPath)
+        for (const [k, v] of Object.entries(hookReq.query)) {
+          if (v !== undefined) url.searchParams.set(k, String(v))
+        }
+
+        const hasBody = hookReq.body !== undefined
+        const response = await fetch(url, {
+          method,
+          headers: {
+            ...(hasBody ? { 'content-type': 'application/json' } : {}),
+            ...hookReq.headers,
+          },
+          body: hasBody ? JSON.stringify(hookReq.body) : undefined,
+        })
+
+        const text = await response.text()
+        let data: unknown
+        try {
+          data = text ? JSON.parse(text) : undefined
+        } catch {
+          data = text
+        }
+
+        await registry.runAfter({
+          key: opKey,
+          request: hookReq,
+          response: { status: response.status, body: data },
+          ctx: store,
+        })
+
+        // \u041F\u043E\u043A\u0430 \u0435\u0441\u0442\u044C \u0431\u044E\u0434\u0436\u0435\u0442 \u043F\u043E\u0432\u0442\u043E\u0440\u043E\u0432 \u2014 \u0441\u043F\u0440\u0430\u0448\u0438\u0432\u0430\u0435\u043C retry-\u0445\u0443\u043A\u0438. \u0412\u0435\u0440\u043D\u0443\u043B\u0438
+        // true \u2192 \u043D\u043E\u0432\u044B\u0439 \u0432\u0438\u0442\u043E\u043A (\u0437\u0430\u043D\u043E\u0432\u043E before \u2192 fetch); \u0438\u043D\u0430\u0447\u0435 \u043E\u0442\u0434\u0430\u0451\u043C \u043E\u0442\u0432\u0435\u0442.
+        if (attempt < maxRetries) {
+          const shouldRetry = await registry.runRetry({
+            key: opKey,
+            request: hookReq,
+            response: { status: response.status, body: data },
+            ctx: store,
+          })
+          if (shouldRetry) {
+            attempt++
+            continue
+          }
+        }
+
+${tailRet}
       }
-
-      const url = new URL(baseUrl + resolvedPath)
-      for (const [k, v] of Object.entries(hookReq.query)) {
-        if (v !== undefined) url.searchParams.set(k, String(v))
-      }
-
-      const hasBody = hookReq.body !== undefined
-      const response = await fetch(url, {
-        method,
-        headers: {
-          ...(hasBody ? { 'content-type': 'application/json' } : {}),
-          ...hookReq.headers,
-        },
-        body: hasBody ? JSON.stringify(hookReq.body) : undefined,
-      })
-
-      const text = await response.text()
-      let data: unknown
-      try {
-        data = text ? JSON.parse(text) : undefined
-      } catch {
-        data = text
-      }
-
-      await registry.runAfter({
-        key: opKey,
-        request: hookReq,
-        response: { status: response.status, body: data },
-        ctx: store,
-      })
-
-${tail.ret}
     }
   }
 

package/dist/index.mjs

@@ -133,6 +133,15 @@ var ApiResponse = class {
 var HookRegistry = class {
   beforeMap = /* @__PURE__ */ new Map();
   afterMap = /* @__PURE__ */ new Map();
+  // Глобальные хуки — срабатывают на КАЖДУЮ операцию (вне зависимости от
+  // ключа). Удобны для сквозных задач: подстановка `Authorization` из
+  // `ctx` во все запросы, логирование, обработка 401 и т.п.
+  globalBeforeHooks = [];
+  globalAfterHooks = [];
+  // Глобальные retry-хуки — решают, переигрывать ли запрос (напр. на 401
+  // сходить за refresh и вернуть `true`). Цикл повторов и его лимит живут
+  // в сгенерированном `request` (см. render.ts) — сам реестр сети не знает.
+  globalRetryHooks = [];
   /** Зарегистрировать `before`-хук на ключ `"<группа>.<метод>"`. */
   before(args) {
     const list = this.beforeMap.get(args.key) ?? [];
@@ -145,18 +154,59 @@ var HookRegistry = class {
     list.push(args.fn);
     this.afterMap.set(args.key, list);
   }
-  /** Прогнать все `before`-хуки ключа по очереди (await на async). */
+  /** Зарегистрировать ГЛОБАЛЬНЫЙ `before`-хук (на все операции). */
+  globalBefore(args) {
+    this.globalBeforeHooks.push(args.fn);
+  }
+  /** Зарегистрировать ГЛОБАЛЬНЫЙ `after`-хук (на все операции). */
+  globalAfter(args) {
+    this.globalAfterHooks.push(args.fn);
+  }
+  /** Зарегистрировать ГЛОБАЛЬНЫЙ `retry`-хук (решает про повтор запроса). */
+  globalRetry(args) {
+    this.globalRetryHooks.push(args.fn);
+  }
+  /**
+   * Прогнать `before`-хуки по очереди (await на async): сначала глобальные,
+   * затем поименные для ключа — так общая подготовка (напр. заголовок
+   * авторизации) ложится раньше, а точечный хук может её переопределить.
+   */
   async runBefore(args) {
-    for (const fn of this.beforeMap.get(args.key) ?? []) {
+    const hooks = [...this.globalBeforeHooks, ...this.beforeMap.get(args.key) ?? []];
+    for (const fn of hooks) {
       await fn({ request: args.request, ctx: args.ctx });
     }
   }
-  /** Прогнать все `after`-хуки ключа по очереди (await на async). */
+  /**
+   * Прогнать `after`-хуки по очереди (await на async): сначала поименные
+   * для ключа, затем глобальные — так глобальный «оборачивает» точечные
+   * (видит итоговый эффект, удобно для логирования/обработки статуса).
+   */
   async runAfter(args) {
-    for (const fn of this.afterMap.get(args.key) ?? []) {
+    const hooks = [...this.afterMap.get(args.key) ?? [], ...this.globalAfterHooks];
+    for (const fn of hooks) {
       await fn({ request: args.request, response: args.response, ctx: args.ctx });
     }
   }
+  /**
+   * Спросить retry-хуки, нужно ли переиграть запрос. Прогон по очереди
+   * регистрации; ПЕРВЫЙ хук, вернувший истину, выигрывает (он уже сделал
+   * подготовку — напр. refresh — поэтому остальные не дёргаем). Если ни
+   * один не вернул истину — `false` (повтора нет). Цикл и лимит повторов
+   * — на стороне вызывающего (сгенерированный `request`).
+   */
+  async runRetry(args) {
+    for (const fn of this.globalRetryHooks) {
+      const decision = await fn({
+        request: args.request,
+        response: args.response,
+        ctx: args.ctx
+      });
+      if (decision)
+        return true;
+    }
+    return false;
+  }
 };
 
 // src/generate-client.ts
@@ -284,8 +334,38 @@ function collectOperations(args) {
       });
     }
   }
+  dedupeNames({ operations });
   return operations;
 }
+function prefixMethod(args) {
+  const { method, name } = args;
+  return method + name.charAt(0).toUpperCase() + name.slice(1);
+}
+function dedupeNames(args) {
+  const { operations } = args;
+  const counts = /* @__PURE__ */ new Map();
+  for (const op of operations) {
+    const byName = counts.get(op.group) ?? /* @__PURE__ */ new Map();
+    byName.set(op.name, (byName.get(op.name) ?? 0) + 1);
+    counts.set(op.group, byName);
+  }
+  const taken = /* @__PURE__ */ new Map();
+  const claim = (group, name) => {
+    const used = taken.get(group) ?? /* @__PURE__ */ new Set();
+    let candidate = name;
+    let i = 2;
+    while (used.has(candidate))
+      candidate = `${name}${i++}`;
+    used.add(candidate);
+    taken.set(group, used);
+    return candidate;
+  };
+  for (const op of operations) {
+    const collides = (counts.get(op.group)?.get(op.name) ?? 0) > 1;
+    const base = collides ? prefixMethod({ method: op.method, name: op.name }) : op.name;
+    op.name = claim(op.group, base);
+  }
+}
 
 // src/generator/render.ts
 function buildInputType(op) {
@@ -350,7 +430,7 @@ function renderImports(args) {
   const { mode, userStoreImport, configImport } = args;
   const values = mode === "frontend" ? "BaseStore, HookRegistry" : "BaseStore, ApiResponse, HookRegistry";
   return `import { ${values} } from ${JSON.stringify(userStoreImport)}
-import type { BeforeHook, AfterHook } from ${JSON.stringify(userStoreImport)}
+import type { BeforeHook, AfterHook, RetryHook } from ${JSON.stringify(userStoreImport)}
 import { ebely } from ${JSON.stringify(configImport)}`;
 }
 function renderRequestTail(mode) {
@@ -409,7 +489,11 @@ function renderHookTreeType(groups) {
 ${leaves.join("\n")}
     }`;
   });
+  const global = `    globalBefore(fn: BeforeHook<Store>): void
+    globalAfter(fn: AfterHook<Store>): void
+    globalRetry(fn: RetryHook<Store>): void`;
   return `type EbelyHookTree<Store extends BaseStore> = {
+${global}
 ${blocks.join("\n")}
 }`;
 }
@@ -429,6 +513,9 @@ ${leaves.join("\n")}
   return `  private buildHookTree(): EbelyHookTree<Store> {
     const r = this.hookRegistry
     return {
+      globalBefore: (fn: BeforeHook<Store>) => r.globalBefore({ fn }),
+      globalAfter: (fn: AfterHook<Store>) => r.globalAfter({ fn }),
+      globalRetry: (fn: RetryHook<Store>) => r.globalRetry({ fn }),
 ${blocks.join("\n")}
     } as unknown as EbelyHookTree<Store>
   }`;
@@ -453,6 +540,7 @@ function renderClient(args) {
   const basePath = spec.servers?.[0]?.url ?? "";
   const groups = groupOperations(operations);
   const tail = renderRequestTail(mode);
+  const tailRet = tail.ret.split("\n").map((l) => l.trim() ? `  ${l}` : l).join("\n");
   return `// AUTO-GENERATED by ebely (generateClient) \u2014 \u041D\u0415 \u0440\u0435\u0434\u0430\u043A\u0442\u0438\u0440\u043E\u0432\u0430\u0442\u044C \u0432\u0440\u0443\u0447\u043D\u0443\u044E.
 // \u0418\u0441\u0442\u043E\u0447\u043D\u0438\u043A: ${spec.info?.title ?? "OpenAPI spec"} v${spec.info?.version ?? "?"}
 // \u0420\u0435\u0436\u0438\u043C \u043A\u043B\u0438\u0435\u043D\u0442\u0430: ${mode}
@@ -558,59 +646,84 @@ ${renderHookTreeBuilder(groups)}
     const baseUrl = this.baseUrl()
     const registry = this.hookRegistry
     const { headers: baseHeaders, store } = cfg
+    // \u041F\u043E\u0442\u043E\u043B\u043E\u043A \u041F\u041E\u0412\u0422\u041E\u0420\u041E\u0412 (\u0441\u0432\u0435\u0440\u0445 \u043F\u0435\u0440\u0432\u043E\u0439 \u043F\u043E\u043F\u044B\u0442\u043A\u0438) \u0434\u043B\u044F globalRetry-\u0445\u0443\u043A\u043E\u0432 \u2014
+    // \u0437\u0430\u0449\u0438\u0442\u0430 \u043E\u0442 \u0431\u0435\u0441\u043A\u043E\u043D\u0435\u0447\u043D\u043E\u0433\u043E \u0446\u0438\u043A\u043B\u0430, \u0435\u0441\u043B\u0438 \u0445\u0443\u043A \u0443\u043F\u0440\u044F\u043C\u043E \u043F\u0440\u043E\u0441\u0438\u0442 \u043F\u043E\u0432\u0442\u043E\u0440.
+    const maxRetries = (ebely as { maxRetries?: number }).maxRetries ?? 3
 
     return async (req): Promise<${tail.returnType}> => {
       const { method, path, opKey, input } = req
 
-      const hookReq = {
-        method,
-        path,
-        pathParams: { ...(input?.path ?? {}) },
-        query: { ...(input?.query ?? {}) },
-        body: input?.body,
-        headers: { ...baseHeaders },
-      }
-      await registry.runBefore({ key: opKey, request: hookReq, ctx: store })
-
-      let resolvedPath = path
-      for (const [k, v] of Object.entries(hookReq.pathParams)) {
-        resolvedPath = resolvedPath.replace(
-          \`{\${k}}\`,
-          encodeURIComponent(String(v)),
-        )
+      // Retry-\u0446\u0438\u043A\u043B: \u043A\u0430\u0436\u0434\u0443\u044E \u043F\u043E\u043F\u044B\u0442\u043A\u0443 hookReq \u0441\u043E\u0431\u0438\u0440\u0430\u0435\u0442\u0441\u044F \u0417\u0410\u041D\u041E\u0412\u041E \u0438 \u0437\u0430\u043D\u043E\u0432\u043E
+      // \u043F\u0440\u043E\u0433\u043E\u043D\u044F\u044E\u0442\u0441\u044F before-\u0445\u0443\u043A\u0438, \u043F\u043E\u044D\u0442\u043E\u043C\u0443 \u043F\u0440\u0430\u0432\u043A\u0438 \u0438\u0437 retry-\u0445\u0443\u043A\u0430 (\u043D\u0430\u043F\u0440.
+      // \u0441\u0432\u0435\u0436\u0438\u0439 \u0442\u043E\u043A\u0435\u043D \u0432 ctx) \u043F\u043E\u0434\u0445\u0432\u0430\u0442\u044B\u0432\u0430\u044E\u0442\u0441\u044F \u043F\u043E\u0432\u0442\u043E\u0440\u043D\u044B\u043C before. \`for (;;)\`
+      // \u043A\u0440\u0443\u0442\u0438\u0442\u0441\u044F, \u043F\u043E\u043A\u0430 \u043D\u0435 \u0441\u0440\u0430\u0431\u043E\u0442\u0430\u0435\u0442 return/throw \u0432 \u0445\u0432\u043E\u0441\u0442\u0435 \u0438\u043B\u0438 \`continue\`.
+      let attempt = 0
+      for (;;) {
+        const hookReq = {
+          method,
+          path,
+          pathParams: { ...(input?.path ?? {}) },
+          query: { ...(input?.query ?? {}) },
+          body: input?.body,
+          headers: { ...baseHeaders },
+        }
+        await registry.runBefore({ key: opKey, request: hookReq, ctx: store })
+
+        let resolvedPath = path
+        for (const [k, v] of Object.entries(hookReq.pathParams)) {
+          resolvedPath = resolvedPath.replace(
+            \`{\${k}}\`,
+            encodeURIComponent(String(v)),
+          )
+        }
+
+        const url = new URL(baseUrl + resolvedPath)
+        for (const [k, v] of Object.entries(hookReq.query)) {
+          if (v !== undefined) url.searchParams.set(k, String(v))
+        }
+
+        const hasBody = hookReq.body !== undefined
+        const response = await fetch(url, {
+          method,
+          headers: {
+            ...(hasBody ? { 'content-type': 'application/json' } : {}),
+            ...hookReq.headers,
+          },
+          body: hasBody ? JSON.stringify(hookReq.body) : undefined,
+        })
+
+        const text = await response.text()
+        let data: unknown
+        try {
+          data = text ? JSON.parse(text) : undefined
+        } catch {
+          data = text
+        }
+
+        await registry.runAfter({
+          key: opKey,
+          request: hookReq,
+          response: { status: response.status, body: data },
+          ctx: store,
+        })
+
+        // \u041F\u043E\u043A\u0430 \u0435\u0441\u0442\u044C \u0431\u044E\u0434\u0436\u0435\u0442 \u043F\u043E\u0432\u0442\u043E\u0440\u043E\u0432 \u2014 \u0441\u043F\u0440\u0430\u0448\u0438\u0432\u0430\u0435\u043C retry-\u0445\u0443\u043A\u0438. \u0412\u0435\u0440\u043D\u0443\u043B\u0438
+        // true \u2192 \u043D\u043E\u0432\u044B\u0439 \u0432\u0438\u0442\u043E\u043A (\u0437\u0430\u043D\u043E\u0432\u043E before \u2192 fetch); \u0438\u043D\u0430\u0447\u0435 \u043E\u0442\u0434\u0430\u0451\u043C \u043E\u0442\u0432\u0435\u0442.
+        if (attempt < maxRetries) {
+          const shouldRetry = await registry.runRetry({
+            key: opKey,
+            request: hookReq,
+            response: { status: response.status, body: data },
+            ctx: store,
+          })
+          if (shouldRetry) {
+            attempt++
+            continue
+          }
+        }
+
+${tailRet}
       }
-
-      const url = new URL(baseUrl + resolvedPath)
-      for (const [k, v] of Object.entries(hookReq.query)) {
-        if (v !== undefined) url.searchParams.set(k, String(v))
-      }
-
-      const hasBody = hookReq.body !== undefined
-      const response = await fetch(url, {
-        method,
-        headers: {
-          ...(hasBody ? { 'content-type': 'application/json' } : {}),
-          ...hookReq.headers,
-        },
-        body: hasBody ? JSON.stringify(hookReq.body) : undefined,
-      })
-
-      const text = await response.text()
-      let data: unknown
-      try {
-        data = text ? JSON.parse(text) : undefined
-      } catch {
-        data = text
-      }
-
-      await registry.runAfter({
-        key: opKey,
-        request: hookReq,
-        response: { status: response.status, body: data },
-        ctx: store,
-      })
-
-${tail.ret}
     }
   }
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "ebely",
   "license": "MIT",
-  "version": "0.0.5",
+  "version": "0.0.7",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
   "types": "dist/index.d.ts",
@@ -35,6 +35,6 @@
     "build": "tsup index.ts --format cjs,esm --dts",
     "release": "pnpm run build && changeset publish",
     "lint": "tsc",
-    "test": "tsx --test src/response.test.ts src/hooks.test.ts src/generator/render.test.ts"
+    "test": "tsx --test src/response.test.ts src/hooks.test.ts src/generator/render.test.ts src/generator/operations.test.ts"
   }
 }