ebely 0.0.6 → 0.1.0

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>;
 }
 
 /**
@@ -176,6 +230,57 @@ type SwaggerSource = {
     pathToFile?: never;
 };
 
+/**
+ * Как кодируются ИМЕНА полей формы для МАССИВА файлов (для одного файла не
+ * важно — всегда одно поле без скобок). Сам wire-формат multipart (RFC 7578)
+ * везде одинаков; различается только именование при массиве:
+ *  - 'repeat'        — files, files, …      (busboy: Express/Nest/Fastify, Go, Rust) — ДЕФОЛТ
+ *  - 'bracket-index' — files[0], files[1]   (oRPC OpenAPI-хендлер, PHP, Rails)
+ *  - 'bracket-empty' — files[], files[]     (PHP/Rails вариант)
+ *  - функция         — кастомная кодировка (escape hatch)
+ */
+type FileEncoding = 'repeat' | 'bracket-index' | 'bracket-empty' | ((args: {
+    form: FormData;
+    field: string;
+    blobs: Blob[];
+}) => void);
+/**
+ * Способы передать файл в типизированный метод клиента. В 90% случаев это
+ * строка-путь или URL (в тестах); во фронтенде — готовый File/Blob.
+ */
+type FileInput = string | URL | {
+    path: string;
+    name?: string;
+    type?: string;
+} | {
+    content: Uint8Array | ArrayBuffer;
+    name: string;
+    type?: string;
+} | Blob | File;
+/** Плоское файловое поле тела: имя свойства + это массив файлов или один. */
+type FileFieldMeta = {
+    name: string;
+    array: boolean;
+};
+/** mime по расширению имени/пути; дефолт — application/octet-stream. */
+declare function mimeFromName(name: string): string;
+/**
+ * Преобразует один {@link FileInput} в Blob (File). Путь читается с диска
+ * через `fs` (Node); готовый File/Blob возвращается как есть (браузер).
+ */
+declare function toBlob(input: FileInput): Promise<Blob>;
+/**
+ * Собирает FormData из тела-объекта: файловые поля кодируются по конвенции
+ * (`encoding`), остальные (скалярные) поля добавляются строками (объекты —
+ * через JSON.stringify). Вызывается уже ПОСЛЕ before-хуков, когда тело —
+ * обычный объект.
+ */
+declare function toMultipartFormData(args: {
+    body: Record<string, unknown>;
+    fileFields: FileFieldMeta[];
+    encoding: FileEncoding;
+}): Promise<FormData>;
+
 /**
  * Режим генерируемого клиента (решается на этапе генерации, влияет на
  * форму сгенерированного файла):
@@ -218,6 +323,16 @@ type EbelyConfig = {
      * @default 'test'
      */
     mode?: ClientMode;
+    /**
+     * Максимальное число ПОВТОРОВ запроса, которые ebely сделает, если
+     * глобальный `retry`-хук (`h.globalRetry`) вернул `true`. Это потолок
+     * на повторы СВЕРХ первой попытки: при `maxRetries: 3` запрос уйдёт
+     * максимум 4 раза. Защита от бесконечного цикла, если хук упрямо просит
+     * повтор (напр. сервер стабильно отвечает 401). Без `globalRetry`-хуков
+     * не влияет ни на что.
+     * @default 3
+     */
+    maxRetries?: number;
     /**
      * Регистратор хуков `before` / `after`. Объявляется в ОТДЕЛЬНОМ
      * типизированном файле (тип `Hooks` экспортирует сгенерированный
@@ -242,6 +357,25 @@ type EbelyConfig = {
      * @default undefined
      */
     hooks?: HooksRegistrar;
+    /**
+     * Настройки отправки файлов (multipart/form-data). `encoding` задаёт, как
+     * кодируются ИМЕНА полей формы для МАССИВА файлов (для одного файла не
+     * важно — всегда одно поле без скобок):
+     *  - `'repeat'`        — files, files, …    (busboy: Express/Nest/Fastify, Go, Rust) — ДЕФОЛТ
+     *  - `'bracket-index'` — files[0], files[1] (oRPC OpenAPI-хендлер, PHP, Rails)
+     *  - `'bracket-empty'` — files[], files[]   (PHP/Rails вариант)
+     *  - функция           — кастомная кодировка (escape hatch)
+     *
+     * Дефолт `'repeat'` — мейнстрим (веб-стандарт). Проектам на oRPC нужно
+     * явно поставить `files: { encoding: 'bracket-index' }`.
+     *
+     * Рантайм-настройка (как `maxRetries`): читается в момент запроса, для
+     * смены перегенерация клиента НЕ нужна.
+     * @default 'repeat'
+     */
+    files?: {
+        encoding?: FileEncoding;
+    };
     /**
      * Из какого модуля СГЕНЕРИРОВАННЫЙ файл импортирует `BaseStore`.
      * По умолчанию `'ebely'` — имя npm-пакета библиотеки. Менять нужно
@@ -270,4 +404,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, FileEncoding, FileFieldMeta, FileInput, HookRegistry, HookRequest, HookResponse, HooksRegistrar, RetryHook, SwaggerSource, generateClient, mimeFromName, toBlob, toMultipartFormData };

package/dist/index.js

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,6 +17,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // index.ts
@@ -24,7 +34,10 @@ __export(evely_exports, {
   BaseStore: () => BaseStore,
   EbelyAssertionError: () => EbelyAssertionError,
   HookRegistry: () => HookRegistry,
-  generateClient: () => generateClient
+  generateClient: () => generateClient,
+  mimeFromName: () => mimeFromName,
+  toBlob: () => toBlob,
+  toMultipartFormData: () => toMultipartFormData
 });
 module.exports = __toCommonJS(evely_exports);
 
@@ -163,6 +176,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 +197,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
@@ -194,6 +257,9 @@ var import_promises2 = require("fs/promises");
 var import_node_path2 = require("path");
 
 // src/generator/schema.ts
+function isFileSchema(schema) {
+  return Boolean(schema) && schema.type === "string" && typeof schema.contentMediaType === "string";
+}
 function schemaToType(args) {
   const { schema, spec, indent = 0 } = args;
   if (!schema)
@@ -202,6 +268,8 @@ function schemaToType(args) {
     const resolved = resolveRef({ ref: schema.$ref, spec });
     return schemaToType({ schema: resolved, spec, indent });
   }
+  if (isFileSchema(schema))
+    return "FileInput";
   for (const key of ["allOf", "oneOf", "anyOf"]) {
     if (Array.isArray(schema[key])) {
       const joiner = key === "allOf" ? " & " : " | ";
@@ -291,7 +359,10 @@ function collectOperations(args) {
       const parameters = op.parameters ?? [];
       const pathParams = parameters.filter((p) => p.in === "path").map((p) => p.name);
       const queryParams = parameters.filter((p) => p.in === "query").map((p) => p.name);
-      const bodySchema = op.requestBody?.content?.["application/json"]?.schema;
+      const content = op.requestBody?.content ?? {};
+      const bodySchema = content["multipart/form-data"]?.schema ?? content["application/json"]?.schema;
+      const fileFields = collectFileFields({ schema: bodySchema, spec });
+      const isMultipart = "multipart/form-data" in content || fileFields.length > 0;
       const responseSchema = pickResponseSchema({ responses: op.responses, spec });
       const responseType = schemaToType({ schema: responseSchema, spec, indent: 3 });
       const declared = collectResponseSchemas({ responses: op.responses, spec });
@@ -308,6 +379,8 @@ function collectOperations(args) {
         queryParams,
         bodyType: bodySchema ? schemaToType({ schema: bodySchema, spec, indent: 4 }) : null,
         bodyRequired: Boolean(op.requestBody?.required),
+        isMultipart,
+        fileFields,
         responseType,
         responses,
         summary: op.summary
@@ -317,6 +390,22 @@ function collectOperations(args) {
   dedupeNames({ operations });
   return operations;
 }
+function collectFileFields(args) {
+  const { schema, spec } = args;
+  const deref = (s) => s && typeof s.$ref === "string" ? resolveRef({ ref: s.$ref, spec }) : s;
+  const root = deref(schema);
+  const props = root?.properties ?? {};
+  const out = [];
+  for (const [name, raw] of Object.entries(props)) {
+    const prop = deref(raw);
+    if (isFileSchema(prop)) {
+      out.push({ name, array: false });
+    } else if (prop?.type === "array" && isFileSchema(deref(prop.items))) {
+      out.push({ name, array: true });
+    }
+  }
+  return out;
+}
 function prefixMethod(args) {
   const { method, name } = args;
   return method + name.charAt(0).toUpperCase() + name.slice(1);
@@ -408,11 +497,23 @@ function renderMethod(args) {
 }
 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)}
+  const core = mode === "frontend" ? "BaseStore, HookRegistry" : "BaseStore, ApiResponse, HookRegistry";
+  return `import { ${core}, toMultipartFormData } from ${JSON.stringify(userStoreImport)}
+import type { BeforeHook, AfterHook, RetryHook } from ${JSON.stringify(userStoreImport)}
+import type { FileInput, FileEncoding, FileFieldMeta } from ${JSON.stringify(userStoreImport)}
 import { ebely } from ${JSON.stringify(configImport)}`;
 }
+function renderFileOps(operations) {
+  const entries = operations.filter((op) => op.isMultipart && op.fileFields.length > 0).map((op) => {
+    const fields = op.fileFields.map((f) => `{ name: ${JSON.stringify(f.name)}, array: ${f.array} }`).join(", ");
+    return `  ${JSON.stringify(hookKey(op))}: [${fields}],`;
+  });
+  if (entries.length === 0)
+    return "const FILE_OPS: Record<string, FileFieldMeta[]> = {}";
+  return `const FILE_OPS: Record<string, FileFieldMeta[]> = {
+${entries.join("\n")}
+}`;
+}
 function renderRequestTail(mode) {
   if (mode === "frontend") {
     return {
@@ -469,7 +570,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")}
 }`;
 }
@@ -489,6 +594,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>
   }`;
@@ -513,6 +621,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}
@@ -520,6 +629,8 @@ function renderClient(args) {
 
 ${renderImports({ mode, userStoreImport, configImport })}
 
+${renderFileOps(operations)}
+
 type RequestInput = {
   path?: Record<string, string>
   query?: Record<string, string | number | boolean | undefined>
@@ -618,59 +729,102 @@ ${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 },
+      // 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
+        // \u0424\u0430\u0439\u043B\u043E\u0432\u044B\u0435 (multipart) \u043E\u043F\u0435\u0440\u0430\u0446\u0438\u0438: FormData \u0441\u043E\u0431\u0438\u0440\u0430\u0435\u0442\u0441\u044F \u041F\u041E\u0421\u041B\u0415 before-\u0445\u0443\u043A\u043E\u0432
+        // (\u0442\u0435\u043B\u043E \u043A \u044D\u0442\u043E\u043C\u0443 \u043C\u043E\u043C\u0435\u043D\u0442\u0443 \u2014 \u043E\u0431\u044B\u0447\u043D\u044B\u0439 \u043E\u0431\u044A\u0435\u043A\u0442, \u0445\u0443\u043A\u0438 \u0432\u0438\u0434\u044F\u0442/\u043F\u0440\u0430\u0432\u044F\u0442 \u0435\u0433\u043E \u043A\u0430\u043A
+        // JSON). \u041A\u043E\u0434\u0438\u0440\u043E\u0432\u043A\u0430 \u0438\u043C\u0451\u043D \u043F\u043E\u043B\u0435\u0439 \u0434\u043B\u044F \u043C\u0430\u0441\u0441\u0438\u0432\u0430 \u0444\u0430\u0439\u043B\u043E\u0432 \u2014 \u0438\u0437 ebely.files
+        // (\u0434\u0435\u0444\u043E\u043B\u0442 'repeat': \u0432\u0435\u0431-\u0441\u0442\u0430\u043D\u0434\u0430\u0440\u0442 busboy/Go/Rust; oRPC \u0441\u0442\u0430\u0432\u0438\u0442
+        // 'bracket-index'). \u041D\u0430 retry FormData \u043F\u0435\u0440\u0435\u0441\u043E\u0431\u0438\u0440\u0430\u0435\u0442\u0441\u044F \u0437\u0430\u043D\u043E\u0432\u043E.
+        const fileFields = FILE_OPS[opKey]
+        const form =
+          fileFields && fileFields.length > 0 && hasBody
+            ? await toMultipartFormData({
+                body: hookReq.body as Record<string, unknown>,
+                fileFields,
+                encoding:
+                  (ebely as { files?: { encoding?: FileEncoding } }).files?.encoding ?? 'repeat',
+              })
+            : undefined
+        const isMultipart = form !== undefined
+
+        const response = await fetch(url, {
+          method,
+          headers: {
+            // multipart: content-type \u041D\u0415 \u0441\u0442\u0430\u0432\u0438\u043C \u2014 fetch \u0441\u0430\u043C \u0432\u044B\u0441\u0442\u0430\u0432\u0438\u0442 boundary.
+            ...(isMultipart ? {} : hasBody ? { 'content-type': 'application/json' } : {}),
+            ...hookReq.headers,
+          },
+          body: isMultipart ? form : 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}
       }
-      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,
-      })
-
-${tail.ret}
     }
   }
 
@@ -742,11 +896,125 @@ Endpoints: ${operations.length}
 `);
   return { outPath, operations: operations.length };
 }
+
+// src/files.ts
+var MIME_BY_EXT = {
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  png: "image/png",
+  gif: "image/gif",
+  webp: "image/webp",
+  avif: "image/avif",
+  bmp: "image/bmp",
+  svg: "image/svg+xml",
+  pdf: "application/pdf",
+  txt: "text/plain",
+  csv: "text/csv",
+  json: "application/json",
+  html: "text/html",
+  xml: "application/xml",
+  mp4: "video/mp4",
+  webm: "video/webm",
+  mp3: "audio/mpeg",
+  wav: "audio/wav",
+  zip: "application/zip"
+};
+function basenameOf(p) {
+  const parts = p.split(/[\\/]/);
+  return parts[parts.length - 1] || p;
+}
+function mimeFromName(name) {
+  const base = basenameOf(name);
+  const dot = base.lastIndexOf(".");
+  const ext = dot <= 0 ? "" : base.slice(dot + 1).toLowerCase();
+  return MIME_BY_EXT[ext] ?? "application/octet-stream";
+}
+async function readPathToBlob(args) {
+  const { readFile: readFile2 } = await import("fs/promises");
+  let filePath;
+  if (args.url) {
+    const { fileURLToPath } = await import("url");
+    filePath = fileURLToPath(args.url);
+  } else {
+    const { resolve: resolve3 } = await import("path");
+    filePath = resolve3(process.cwd(), args.path ?? "");
+  }
+  const bytes = await readFile2(filePath);
+  const name = args.name ?? basenameOf(filePath);
+  const type = args.type ?? mimeFromName(filePath);
+  return new File([bytes], name, { type });
+}
+async function toBlob(input) {
+  if (input instanceof Blob)
+    return input;
+  if (input instanceof URL)
+    return readPathToBlob({ url: input });
+  if (typeof input === "object" && "content" in input) {
+    const { content, name, type } = input;
+    return new File([content], name, { type: type ?? mimeFromName(name) });
+  }
+  if (typeof input === "object" && "path" in input) {
+    return readPathToBlob({ path: input.path, name: input.name, type: input.type });
+  }
+  if (input.startsWith("file://"))
+    return readPathToBlob({ url: new URL(input) });
+  return readPathToBlob({ path: input });
+}
+function appendArray(args) {
+  const { form, field, blobs, encoding } = args;
+  if (typeof encoding === "function") {
+    encoding({ form, field, blobs });
+    return;
+  }
+  switch (encoding) {
+    case "bracket-index":
+      blobs.forEach((b, i) => form.append(`${field}[${i}]`, b));
+      return;
+    case "bracket-empty":
+      for (const b of blobs)
+        form.append(`${field}[]`, b);
+      return;
+    case "repeat":
+    default:
+      for (const b of blobs)
+        form.append(field, b);
+      return;
+  }
+}
+async function toMultipartFormData(args) {
+  const { body, fileFields, encoding } = args;
+  const form = new FormData();
+  const fileFieldNames = new Set(fileFields.map((f) => f.name));
+  for (const field of fileFields) {
+    const value = body[field.name];
+    if (value === void 0 || value === null)
+      continue;
+    if (field.array) {
+      const inputs = Array.isArray(value) ? value : [value];
+      const blobs = await Promise.all(inputs.map((i) => toBlob(i)));
+      appendArray({ form, field: field.name, blobs, encoding });
+    } else {
+      const blob = await toBlob(value);
+      form.append(field.name, blob);
+    }
+  }
+  for (const [key, value] of Object.entries(body)) {
+    if (fileFieldNames.has(key))
+      continue;
+    if (value === void 0)
+      continue;
+    form.append(key, typeof value === "object" ? JSON.stringify(value) : String(value));
+  }
+  return form;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ApiResponse,
   BaseStore,
   EbelyAssertionError,
   HookRegistry,
-  generateClient
+  generateClient,
+  mimeFromName,
+  toBlob,
+  toMultipartFormData
 });

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
@@ -164,6 +214,9 @@ import { writeFile } from "fs/promises";
 import { resolve as resolve2 } from "path";
 
 // src/generator/schema.ts
+function isFileSchema(schema) {
+  return Boolean(schema) && schema.type === "string" && typeof schema.contentMediaType === "string";
+}
 function schemaToType(args) {
   const { schema, spec, indent = 0 } = args;
   if (!schema)
@@ -172,6 +225,8 @@ function schemaToType(args) {
     const resolved = resolveRef({ ref: schema.$ref, spec });
     return schemaToType({ schema: resolved, spec, indent });
   }
+  if (isFileSchema(schema))
+    return "FileInput";
   for (const key of ["allOf", "oneOf", "anyOf"]) {
     if (Array.isArray(schema[key])) {
       const joiner = key === "allOf" ? " & " : " | ";
@@ -261,7 +316,10 @@ function collectOperations(args) {
       const parameters = op.parameters ?? [];
       const pathParams = parameters.filter((p) => p.in === "path").map((p) => p.name);
       const queryParams = parameters.filter((p) => p.in === "query").map((p) => p.name);
-      const bodySchema = op.requestBody?.content?.["application/json"]?.schema;
+      const content = op.requestBody?.content ?? {};
+      const bodySchema = content["multipart/form-data"]?.schema ?? content["application/json"]?.schema;
+      const fileFields = collectFileFields({ schema: bodySchema, spec });
+      const isMultipart = "multipart/form-data" in content || fileFields.length > 0;
       const responseSchema = pickResponseSchema({ responses: op.responses, spec });
       const responseType = schemaToType({ schema: responseSchema, spec, indent: 3 });
       const declared = collectResponseSchemas({ responses: op.responses, spec });
@@ -278,6 +336,8 @@ function collectOperations(args) {
         queryParams,
         bodyType: bodySchema ? schemaToType({ schema: bodySchema, spec, indent: 4 }) : null,
         bodyRequired: Boolean(op.requestBody?.required),
+        isMultipart,
+        fileFields,
         responseType,
         responses,
         summary: op.summary
@@ -287,6 +347,22 @@ function collectOperations(args) {
   dedupeNames({ operations });
   return operations;
 }
+function collectFileFields(args) {
+  const { schema, spec } = args;
+  const deref = (s) => s && typeof s.$ref === "string" ? resolveRef({ ref: s.$ref, spec }) : s;
+  const root = deref(schema);
+  const props = root?.properties ?? {};
+  const out = [];
+  for (const [name, raw] of Object.entries(props)) {
+    const prop = deref(raw);
+    if (isFileSchema(prop)) {
+      out.push({ name, array: false });
+    } else if (prop?.type === "array" && isFileSchema(deref(prop.items))) {
+      out.push({ name, array: true });
+    }
+  }
+  return out;
+}
 function prefixMethod(args) {
   const { method, name } = args;
   return method + name.charAt(0).toUpperCase() + name.slice(1);
@@ -378,11 +454,23 @@ function renderMethod(args) {
 }
 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)}
+  const core = mode === "frontend" ? "BaseStore, HookRegistry" : "BaseStore, ApiResponse, HookRegistry";
+  return `import { ${core}, toMultipartFormData } from ${JSON.stringify(userStoreImport)}
+import type { BeforeHook, AfterHook, RetryHook } from ${JSON.stringify(userStoreImport)}
+import type { FileInput, FileEncoding, FileFieldMeta } from ${JSON.stringify(userStoreImport)}
 import { ebely } from ${JSON.stringify(configImport)}`;
 }
+function renderFileOps(operations) {
+  const entries = operations.filter((op) => op.isMultipart && op.fileFields.length > 0).map((op) => {
+    const fields = op.fileFields.map((f) => `{ name: ${JSON.stringify(f.name)}, array: ${f.array} }`).join(", ");
+    return `  ${JSON.stringify(hookKey(op))}: [${fields}],`;
+  });
+  if (entries.length === 0)
+    return "const FILE_OPS: Record<string, FileFieldMeta[]> = {}";
+  return `const FILE_OPS: Record<string, FileFieldMeta[]> = {
+${entries.join("\n")}
+}`;
+}
 function renderRequestTail(mode) {
   if (mode === "frontend") {
     return {
@@ -439,7 +527,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 +551,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 +578,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}
@@ -490,6 +586,8 @@ function renderClient(args) {
 
 ${renderImports({ mode, userStoreImport, configImport })}
 
+${renderFileOps(operations)}
+
 type RequestInput = {
   path?: Record<string, string>
   query?: Record<string, string | number | boolean | undefined>
@@ -588,59 +686,102 @@ ${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 },
+      // 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
+        // \u0424\u0430\u0439\u043B\u043E\u0432\u044B\u0435 (multipart) \u043E\u043F\u0435\u0440\u0430\u0446\u0438\u0438: FormData \u0441\u043E\u0431\u0438\u0440\u0430\u0435\u0442\u0441\u044F \u041F\u041E\u0421\u041B\u0415 before-\u0445\u0443\u043A\u043E\u0432
+        // (\u0442\u0435\u043B\u043E \u043A \u044D\u0442\u043E\u043C\u0443 \u043C\u043E\u043C\u0435\u043D\u0442\u0443 \u2014 \u043E\u0431\u044B\u0447\u043D\u044B\u0439 \u043E\u0431\u044A\u0435\u043A\u0442, \u0445\u0443\u043A\u0438 \u0432\u0438\u0434\u044F\u0442/\u043F\u0440\u0430\u0432\u044F\u0442 \u0435\u0433\u043E \u043A\u0430\u043A
+        // JSON). \u041A\u043E\u0434\u0438\u0440\u043E\u0432\u043A\u0430 \u0438\u043C\u0451\u043D \u043F\u043E\u043B\u0435\u0439 \u0434\u043B\u044F \u043C\u0430\u0441\u0441\u0438\u0432\u0430 \u0444\u0430\u0439\u043B\u043E\u0432 \u2014 \u0438\u0437 ebely.files
+        // (\u0434\u0435\u0444\u043E\u043B\u0442 'repeat': \u0432\u0435\u0431-\u0441\u0442\u0430\u043D\u0434\u0430\u0440\u0442 busboy/Go/Rust; oRPC \u0441\u0442\u0430\u0432\u0438\u0442
+        // 'bracket-index'). \u041D\u0430 retry FormData \u043F\u0435\u0440\u0435\u0441\u043E\u0431\u0438\u0440\u0430\u0435\u0442\u0441\u044F \u0437\u0430\u043D\u043E\u0432\u043E.
+        const fileFields = FILE_OPS[opKey]
+        const form =
+          fileFields && fileFields.length > 0 && hasBody
+            ? await toMultipartFormData({
+                body: hookReq.body as Record<string, unknown>,
+                fileFields,
+                encoding:
+                  (ebely as { files?: { encoding?: FileEncoding } }).files?.encoding ?? 'repeat',
+              })
+            : undefined
+        const isMultipart = form !== undefined
+
+        const response = await fetch(url, {
+          method,
+          headers: {
+            // multipart: content-type \u041D\u0415 \u0441\u0442\u0430\u0432\u0438\u043C \u2014 fetch \u0441\u0430\u043C \u0432\u044B\u0441\u0442\u0430\u0432\u0438\u0442 boundary.
+            ...(isMultipart ? {} : hasBody ? { 'content-type': 'application/json' } : {}),
+            ...hookReq.headers,
+          },
+          body: isMultipart ? form : 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}
       }
-      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,
-      })
-
-${tail.ret}
     }
   }
 
@@ -712,10 +853,124 @@ Endpoints: ${operations.length}
 `);
   return { outPath, operations: operations.length };
 }
+
+// src/files.ts
+var MIME_BY_EXT = {
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  png: "image/png",
+  gif: "image/gif",
+  webp: "image/webp",
+  avif: "image/avif",
+  bmp: "image/bmp",
+  svg: "image/svg+xml",
+  pdf: "application/pdf",
+  txt: "text/plain",
+  csv: "text/csv",
+  json: "application/json",
+  html: "text/html",
+  xml: "application/xml",
+  mp4: "video/mp4",
+  webm: "video/webm",
+  mp3: "audio/mpeg",
+  wav: "audio/wav",
+  zip: "application/zip"
+};
+function basenameOf(p) {
+  const parts = p.split(/[\\/]/);
+  return parts[parts.length - 1] || p;
+}
+function mimeFromName(name) {
+  const base = basenameOf(name);
+  const dot = base.lastIndexOf(".");
+  const ext = dot <= 0 ? "" : base.slice(dot + 1).toLowerCase();
+  return MIME_BY_EXT[ext] ?? "application/octet-stream";
+}
+async function readPathToBlob(args) {
+  const { readFile: readFile2 } = await import("fs/promises");
+  let filePath;
+  if (args.url) {
+    const { fileURLToPath } = await import("url");
+    filePath = fileURLToPath(args.url);
+  } else {
+    const { resolve: resolve3 } = await import("path");
+    filePath = resolve3(process.cwd(), args.path ?? "");
+  }
+  const bytes = await readFile2(filePath);
+  const name = args.name ?? basenameOf(filePath);
+  const type = args.type ?? mimeFromName(filePath);
+  return new File([bytes], name, { type });
+}
+async function toBlob(input) {
+  if (input instanceof Blob)
+    return input;
+  if (input instanceof URL)
+    return readPathToBlob({ url: input });
+  if (typeof input === "object" && "content" in input) {
+    const { content, name, type } = input;
+    return new File([content], name, { type: type ?? mimeFromName(name) });
+  }
+  if (typeof input === "object" && "path" in input) {
+    return readPathToBlob({ path: input.path, name: input.name, type: input.type });
+  }
+  if (input.startsWith("file://"))
+    return readPathToBlob({ url: new URL(input) });
+  return readPathToBlob({ path: input });
+}
+function appendArray(args) {
+  const { form, field, blobs, encoding } = args;
+  if (typeof encoding === "function") {
+    encoding({ form, field, blobs });
+    return;
+  }
+  switch (encoding) {
+    case "bracket-index":
+      blobs.forEach((b, i) => form.append(`${field}[${i}]`, b));
+      return;
+    case "bracket-empty":
+      for (const b of blobs)
+        form.append(`${field}[]`, b);
+      return;
+    case "repeat":
+    default:
+      for (const b of blobs)
+        form.append(field, b);
+      return;
+  }
+}
+async function toMultipartFormData(args) {
+  const { body, fileFields, encoding } = args;
+  const form = new FormData();
+  const fileFieldNames = new Set(fileFields.map((f) => f.name));
+  for (const field of fileFields) {
+    const value = body[field.name];
+    if (value === void 0 || value === null)
+      continue;
+    if (field.array) {
+      const inputs = Array.isArray(value) ? value : [value];
+      const blobs = await Promise.all(inputs.map((i) => toBlob(i)));
+      appendArray({ form, field: field.name, blobs, encoding });
+    } else {
+      const blob = await toBlob(value);
+      form.append(field.name, blob);
+    }
+  }
+  for (const [key, value] of Object.entries(body)) {
+    if (fileFieldNames.has(key))
+      continue;
+    if (value === void 0)
+      continue;
+    form.append(key, typeof value === "object" ? JSON.stringify(value) : String(value));
+  }
+  return form;
+}
 export {
   ApiResponse,
   BaseStore,
   EbelyAssertionError,
   HookRegistry,
-  generateClient
+  generateClient,
+  mimeFromName,
+  toBlob,
+  toMultipartFormData
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "ebely",
   "license": "MIT",
-  "version": "0.0.6",
+  "version": "0.1.0",
   "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 src/generator/operations.test.ts"
+    "test": "tsx --test src/response.test.ts src/hooks.test.ts src/files.test.ts src/generator/render.test.ts src/generator/operations.test.ts src/generator/schema.test.ts"
   }
 }