ebely 0.0.1 → 0.0.2

package/dist/index.js

@@ -0,0 +1,722 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// index.ts
+var evely_exports = {};
+__export(evely_exports, {
+  ApiResponse: () => ApiResponse,
+  BaseStore: () => BaseStore,
+  EbelyAssertionError: () => EbelyAssertionError,
+  HookRegistry: () => HookRegistry,
+  generateClient: () => generateClient
+});
+module.exports = __toCommonJS(evely_exports);
+
+// src/base-store.ts
+var BaseStore = class {
+  store = /* @__PURE__ */ new Map();
+  /**
+   * Типизированный доступ к эндпоинтам ИЗНУТРИ методов-сценариев
+   * («actions»): `this.api.<группа>.<метод>(...)`. Само значение
+   * подставляет генерируемый `World` (для user-store — клиент этого
+   * пользователя, для world-store — анонимный клиент), поэтому здесь это
+   * объявление без инициализатора. Тип `Api` пользователь задаёт вторым
+   * дженериком, передавая сгенерированный `WorldApi`:
+   *
+   *   import type { WorldApi } from './generated'
+   *   class UserStore extends BaseStore<Vars, WorldApi> {
+   *     async fullRegister(args: { email: string; password: string }) {
+   *       await this.api.auth.register({ body: args })
+   *       await this.api.auth.confirm({ body: { code: '0000' } })
+   *     }
+   *   }
+   *
+   * (Тип импортируется как `import type` → рантайм-цикла нет, ровно как
+   * у `hooks.ts`; см. ARCHITECTURE.md §7–§8.)
+   */
+  api;
+  /** Сохранить внутреннюю переменную пользователя. */
+  set(args) {
+    this.store.set(args.key, args.value);
+  }
+  /** Прочитать внутреннюю переменную пользователя (undefined, если не задана). */
+  get(args) {
+    return this.store.get(args.key);
+  }
+};
+
+// src/response.ts
+var EbelyAssertionError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "EbelyAssertionError";
+  }
+};
+function safeJson(value) {
+  try {
+    return JSON.stringify(value) ?? String(value);
+  } catch {
+    return String(value);
+  }
+}
+function matchPartial(args) {
+  const { actual, expected, path = "" } = args;
+  if (Array.isArray(expected)) {
+    if (!Array.isArray(actual))
+      return { path, expected, actual };
+    for (let i = 0; i < expected.length; i++) {
+      const m = matchPartial({
+        actual: actual[i],
+        expected: expected[i],
+        path: `${path}[${i}]`
+      });
+      if (m)
+        return m;
+    }
+    return null;
+  }
+  if (expected !== null && typeof expected === "object") {
+    if (actual === null || typeof actual !== "object" || Array.isArray(actual)) {
+      return { path, expected, actual };
+    }
+    const exp = expected;
+    const act = actual;
+    for (const key of Object.keys(exp)) {
+      const m = matchPartial({
+        actual: act[key],
+        expected: exp[key],
+        path: path ? `${path}.${key}` : key
+      });
+      if (m)
+        return m;
+    }
+    return null;
+  }
+  return Object.is(actual, expected) ? null : { path, expected, actual };
+}
+function assertResponse(args) {
+  const { actualStatus, actualBody, expectedStatus, expectedBody } = args;
+  if (actualStatus !== expectedStatus) {
+    throw new EbelyAssertionError(
+      `\u041E\u0436\u0438\u0434\u0430\u043B\u0441\u044F \u0441\u0442\u0430\u0442\u0443\u0441 ${expectedStatus}, \u043F\u043E\u043B\u0443\u0447\u0435\u043D ${actualStatus}.
+\u0422\u0435\u043B\u043E \u043E\u0442\u0432\u0435\u0442\u0430: ${safeJson(actualBody)}`
+    );
+  }
+  if (expectedBody === void 0)
+    return;
+  const mismatch = matchPartial({ actual: actualBody, expected: expectedBody });
+  if (mismatch) {
+    throw new EbelyAssertionError(
+      `\u0422\u0435\u043B\u043E \u043E\u0442\u0432\u0435\u0442\u0430 \u043D\u0435 \u0441\u043E\u0432\u043F\u0430\u043B\u043E \u043F\u043E \u043F\u0443\u0442\u0438 "${mismatch.path || "<root>"}": \u043E\u0436\u0438\u0434\u0430\u043B\u043E\u0441\u044C ${safeJson(mismatch.expected)}, \u043F\u043E\u043B\u0443\u0447\u0435\u043D\u043E ${safeJson(mismatch.actual)}.
+\u041F\u043E\u043B\u043D\u043E\u0435 \u0442\u0435\u043B\u043E: ${safeJson(actualBody)}`
+    );
+  }
+}
+var ApiResponse = class {
+  /** Фактический HTTP-статус ответа. */
+  status;
+  /** Распарсенное тело ответа. */
+  body;
+  constructor(args) {
+    this.status = args.status;
+    this.body = args.body;
+  }
+  /**
+   * Проверяет статус и (опционально) часть тела ответа.
+   *
+   * @param status Ожидаемый статус. Подсказывается интеллисенсом из
+   *   swagger; незадекларированный литерал — ошибка типов. Чтобы
+   *   проверить статус, которого нет в схеме (например `400`),
+   *   используйте `res.assert(400 as any, ...)`.
+   * @param expectedBody Необязательная часть тела: проверяются только
+   *   переданные поля (глубоко-частично), остальные игнорируются.
+   * @returns тот же объект ответа — удобно читать `.body` после проверки.
+   */
+  assert(status, expectedBody) {
+    assertResponse({
+      actualStatus: this.status,
+      actualBody: this.body,
+      expectedStatus: status,
+      expectedBody
+    });
+    return this;
+  }
+};
+
+// src/hooks.ts
+var HookRegistry = class {
+  beforeMap = /* @__PURE__ */ new Map();
+  afterMap = /* @__PURE__ */ new Map();
+  /** Зарегистрировать `before`-хук на ключ `"<группа>.<метод>"`. */
+  before(args) {
+    const list = this.beforeMap.get(args.key) ?? [];
+    list.push(args.fn);
+    this.beforeMap.set(args.key, list);
+  }
+  /** Зарегистрировать `after`-хук на ключ `"<группа>.<метод>"`. */
+  after(args) {
+    const list = this.afterMap.get(args.key) ?? [];
+    list.push(args.fn);
+    this.afterMap.set(args.key, list);
+  }
+  /** Прогнать все `before`-хуки ключа по очереди (await на async). */
+  async runBefore(args) {
+    for (const fn of this.beforeMap.get(args.key) ?? []) {
+      await fn({ request: args.request, ctx: args.ctx });
+    }
+  }
+  /** Прогнать все `after`-хуки ключа по очереди (await на async). */
+  async runAfter(args) {
+    for (const fn of this.afterMap.get(args.key) ?? []) {
+      await fn({ request: args.request, response: args.response, ctx: args.ctx });
+    }
+  }
+};
+
+// src/generate-client.ts
+var import_promises2 = require("fs/promises");
+var import_node_path2 = require("path");
+
+// src/generator/schema.ts
+function schemaToType(args) {
+  const { schema, spec, indent = 0 } = args;
+  if (!schema)
+    return "unknown";
+  if (typeof schema.$ref === "string") {
+    const resolved = resolveRef({ ref: schema.$ref, spec });
+    return schemaToType({ schema: resolved, spec, indent });
+  }
+  for (const key of ["allOf", "oneOf", "anyOf"]) {
+    if (Array.isArray(schema[key])) {
+      const joiner = key === "allOf" ? " & " : " | ";
+      return schema[key].map((s) => schemaToType({ schema: s, spec, indent })).join(joiner);
+    }
+  }
+  if (Array.isArray(schema.enum)) {
+    return schema.enum.map((v) => JSON.stringify(v)).join(" | ");
+  }
+  const types = Array.isArray(schema.type) ? schema.type : [schema.type];
+  const rendered = types.map((type) => {
+    switch (type) {
+      case "string":
+        return "string";
+      case "number":
+      case "integer":
+        return "number";
+      case "boolean":
+        return "boolean";
+      case "null":
+        return "null";
+      case "array":
+        return `Array<${schemaToType({ schema: schema.items, spec, indent })}>`;
+      case "object": {
+        const props = schema.properties ?? {};
+        const required = schema.required ?? [];
+        const keys = Object.keys(props);
+        if (keys.length === 0)
+          return "Record<string, unknown>";
+        const pad = "  ".repeat(indent + 1);
+        const closePad = "  ".repeat(indent);
+        const lines = keys.map((k) => {
+          const optional = required.includes(k) ? "" : "?";
+          const valueType = schemaToType({ schema: props[k], spec, indent: indent + 1 });
+          return `${pad}${JSON.stringify(k)}${optional}: ${valueType}`;
+        });
+        return `{
+${lines.join("\n")}
+${closePad}}`;
+      }
+      default:
+        return "unknown";
+    }
+  });
+  return rendered.join(" | ");
+}
+function resolveRef(args) {
+  const { ref, spec } = args;
+  if (!ref.startsWith("#/"))
+    return void 0;
+  return ref.slice(2).split("/").reduce((acc, part) => acc ? acc[part] : void 0, spec);
+}
+function pickResponseSchema(args) {
+  const { responses } = args;
+  const status = Object.keys(responses ?? {}).find((s) => s.startsWith("2")) ?? "default";
+  return responses?.[status]?.content?.["application/json"]?.schema;
+}
+function collectResponseSchemas(args) {
+  const { responses } = args;
+  const out = [];
+  for (const key of Object.keys(responses ?? {})) {
+    const status = Number(key);
+    if (!Number.isInteger(status))
+      continue;
+    out.push({
+      status,
+      schema: responses[key]?.content?.["application/json"]?.schema
+    });
+  }
+  return out;
+}
+
+// src/generator/operations.ts
+var HTTP_METHODS = ["get", "post", "put", "patch", "delete"];
+function collectOperations(args) {
+  const { spec } = args;
+  const operations = [];
+  for (const [path, pathItem] of Object.entries(spec.paths ?? {})) {
+    for (const method of HTTP_METHODS) {
+      const op = pathItem[method];
+      if (!op)
+        continue;
+      const operationId = op.operationId ?? `${method}${path}`;
+      const dotIndex = operationId.indexOf(".");
+      const group = dotIndex === -1 ? "default" : operationId.slice(0, dotIndex);
+      const name = dotIndex === -1 ? operationId : operationId.slice(dotIndex + 1);
+      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 responseSchema = pickResponseSchema({ responses: op.responses, spec });
+      const responseType = schemaToType({ schema: responseSchema, spec, indent: 3 });
+      const declared = collectResponseSchemas({ responses: op.responses, spec });
+      const responses = declared.length > 0 ? declared.map((r) => ({
+        status: r.status,
+        bodyType: schemaToType({ schema: r.schema, spec, indent: 4 })
+      })) : [{ status: 200, bodyType: responseType }];
+      operations.push({
+        group,
+        name,
+        method,
+        path,
+        pathParams,
+        queryParams,
+        bodyType: bodySchema ? schemaToType({ schema: bodySchema, spec, indent: 4 }) : null,
+        bodyRequired: Boolean(op.requestBody?.required),
+        responseType,
+        responses,
+        summary: op.summary
+      });
+    }
+  }
+  return operations;
+}
+
+// src/generator/render.ts
+function buildInputType(op) {
+  const parts = [];
+  if (op.pathParams.length > 0) {
+    const fields = op.pathParams.map((p) => `${JSON.stringify(p)}: string`).join("; ");
+    parts.push(`path: { ${fields} }`);
+  }
+  if (op.queryParams.length > 0) {
+    const fields = op.queryParams.map((p) => `${JSON.stringify(p)}?: string | number | boolean`).join("; ");
+    parts.push(`query?: { ${fields} }`);
+  }
+  if (op.bodyType) {
+    parts.push(`body${op.bodyRequired ? "" : "?"}: ${op.bodyType}`);
+  }
+  if (parts.length === 0)
+    return { type: "{}", optional: true };
+  const optional = op.pathParams.length === 0 && (!op.bodyType || !op.bodyRequired);
+  return { type: `{ ${parts.join("; ")} }`, optional };
+}
+function buildStatusMapType(op) {
+  const entries = op.responses.map((r) => `${r.status}: ${r.bodyType}`);
+  return `{ ${entries.join("; ")} }`;
+}
+function methodReturnType(args) {
+  const { op, mode } = args;
+  if (mode === "frontend")
+    return `Promise<${op.responseType}>`;
+  return `Promise<ApiResponse<${buildStatusMapType(op)}>>`;
+}
+function hookKey(op) {
+  return `${op.group}.${op.name}`;
+}
+function hookBodyType(op) {
+  return op.bodyType ?? "undefined";
+}
+function renderMethod(args) {
+  const { op, mode } = args;
+  const { type, optional } = buildInputType(op);
+  const inputParam = `input${optional ? "?" : ""}: ${type}`;
+  const doc = op.summary ? `
+        /** ${op.summary} */` : "";
+  const call = `request({
+            method: ${JSON.stringify(op.method.toUpperCase())},
+            path: ${JSON.stringify(op.path)},
+            opKey: ${JSON.stringify(hookKey(op))},
+            input: input as RequestInput,
+          })`;
+  if (mode === "frontend") {
+    return `${doc}
+        ${JSON.stringify(op.name)}: (${inputParam}): Promise<${op.responseType}> =>
+          ${call} as Promise<${op.responseType}>,`;
+  }
+  const map = buildStatusMapType(op);
+  return `${doc}
+        ${JSON.stringify(op.name)}: async (${inputParam}): Promise<ApiResponse<${map}>> => {
+          const res = await ${call}
+          return new ApiResponse(res) as unknown as ApiResponse<${map}>
+        },`;
+}
+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 { ebely } from ${JSON.stringify(configImport)}`;
+}
+function renderRequestTail(mode) {
+  if (mode === "frontend") {
+    return {
+      returnType: "unknown",
+      ret: `      if (!response.ok) {
+        throw new Error(
+          \`Request \${method} \${resolvedPath} failed with \${response.status}: \${text}\`,
+        )
+      }
+
+      return data`
+    };
+  }
+  return {
+    returnType: "{ status: number; body: unknown }",
+    ret: `      return { status: response.status, body: data }`
+  };
+}
+function groupOperations(operations) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const op of operations) {
+    const list = groups.get(op.group) ?? [];
+    list.push(op);
+    groups.set(op.group, list);
+  }
+  return groups;
+}
+function renderApiType(args) {
+  const { groups, mode } = args;
+  const blocks = [...groups.entries()].map(([group, ops]) => {
+    const leaves = ops.map((op) => {
+      const { type, optional } = buildInputType(op);
+      const inputParam = `input${optional ? "?" : ""}: ${type}`;
+      return `      ${JSON.stringify(op.name)}: (${inputParam}) => ${methodReturnType({ op, mode })}`;
+    });
+    return `    ${JSON.stringify(group)}: {
+${leaves.join("\n")}
+    }`;
+  });
+  return `export type WorldApi = {
+${blocks.join("\n")}
+}`;
+}
+function renderHookTreeType(groups) {
+  const blocks = [...groups.entries()].map(([group, ops]) => {
+    const leaves = ops.map((op) => {
+      const body = hookBodyType(op);
+      return `      ${JSON.stringify(op.name)}: {
+        before(fn: BeforeHook<Store, ${body}>): void
+        after(fn: AfterHook<Store, ${body}, ${op.responseType}>): void
+      }`;
+    });
+    return `    ${JSON.stringify(group)}: {
+${leaves.join("\n")}
+    }`;
+  });
+  return `type EbelyHookTree<Store extends BaseStore> = {
+${blocks.join("\n")}
+}`;
+}
+function renderHookTreeBuilder(groups) {
+  const blocks = [...groups.entries()].map(([group, ops]) => {
+    const leaves = ops.map((op) => {
+      const key = JSON.stringify(hookKey(op));
+      return `        ${JSON.stringify(op.name)}: {
+          before: (fn: BeforeHook<Store>) => r.before({ key: ${key}, fn }),
+          after: (fn: AfterHook<Store>) => r.after({ key: ${key}, fn }),
+        },`;
+    });
+    return `      ${JSON.stringify(group)}: {
+${leaves.join("\n")}
+      },`;
+  });
+  return `  private buildHookTree(): EbelyHookTree<Store> {
+    const r = this.hookRegistry
+    return {
+${blocks.join("\n")}
+    } as unknown as EbelyHookTree<Store>
+  }`;
+}
+function renderApiTreeBuilder(args) {
+  const { groups, mode } = args;
+  const groupBlocks = [...groups.entries()].map(([group, ops]) => {
+    const methods = ops.map((op) => renderMethod({ op, mode }));
+    return `      ${JSON.stringify(group)}: {
+${methods.join("\n")}
+      },`;
+  });
+  return `  /** \u0414\u0435\u0440\u0435\u0432\u043E \u0442\u0438\u043F\u0438\u0437\u0438\u0440\u043E\u0432\u0430\u043D\u043D\u044B\u0445 \u0432\u044B\u0437\u043E\u0432\u043E\u0432 \u044D\u043D\u0434\u043F\u043E\u0438\u043D\u0442\u043E\u0432 \u043F\u043E\u0432\u0435\u0440\u0445 \u043E\u0434\u043D\u043E\u0433\u043E \`request\`. */
+  private buildApiTree(request: RequestFn) {
+    return {
+${groupBlocks.join("\n")}
+    }
+  }`;
+}
+function renderClient(args) {
+  const { spec, operations, mode, userStoreImport, configImport } = args;
+  const basePath = spec.servers?.[0]?.url ?? "";
+  const groups = groupOperations(operations);
+  const tail = renderRequestTail(mode);
+  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}
+// \u041F\u0435\u0440\u0435\u0433\u0435\u043D\u0435\u0440\u0430\u0446\u0438\u044F: pnpm run client:generate
+
+${renderImports({ mode, userStoreImport, configImport })}
+
+type RequestInput = {
+  path?: Record<string, string>
+  query?: Record<string, string | number | boolean | undefined>
+  body?: unknown
+}
+
+type RequestFn = (req: {
+  method: string
+  path: string
+  opKey: string
+  input?: RequestInput
+}) => Promise<${tail.returnType}>
+
+export type CreateUserArgs = {
+  /** \u0417\u0430\u0433\u043E\u043B\u043E\u0432\u043A\u0438, \u043A\u043E\u0442\u043E\u0440\u044B\u0435 \u0431\u0443\u0434\u0443\u0442 \u0434\u043E\u0431\u0430\u0432\u043B\u044F\u0442\u044C\u0441\u044F \u043A\u043E \u0432\u0441\u0435\u043C \u0437\u0430\u043F\u0440\u043E\u0441\u0430\u043C \u044D\u0442\u043E\u0433\u043E \u043F\u043E\u043B\u044C\u0437\u043E\u0432\u0430\u0442\u0435\u043B\u044F. */
+  headers?: Record<string, string>
+}
+
+${renderApiType({ groups, mode })}
+
+${renderHookTreeType(groups)}
+
+/**
+ * \u0422\u0438\u043F \u0440\u0435\u0433\u0438\u0441\u0442\u0440\u0430\u0442\u043E\u0440\u0430 \u0445\u0443\u043A\u043E\u0432 \u0434\u043B\u044F \u042D\u0422\u041E\u0413\u041E \u0431\u044D\u043A\u0435\u043D\u0434\u0430. \u041E\u0431\u044A\u044F\u0432\u0438\u0442\u0435 \u0445\u0443\u043A\u0438 \u0432 \u043E\u0442\u0434\u0435\u043B\u044C\u043D\u043E\u043C
+ * \u0444\u0430\u0439\u043B\u0435 \u0438 \u043F\u043E\u043B\u043E\u0436\u0438\u0442\u0435 \u043E\u0434\u043D\u043E\u0439 \u043F\u0435\u0440\u0435\u043C\u0435\u043D\u043D\u043E\u0439 \u0432 \u043A\u043E\u043D\u0444\u0438\u0433 (\`EbelyConfig.hooks\`).
+ * \u041F\u0435\u0440\u0435\u0434\u0430\u0439\u0442\u0435 \u0421\u0412\u041E\u0419 \u043A\u043B\u0430\u0441\u0441 store \u043F\u0430\u0440\u0430\u043C\u0435\u0442\u0440\u043E\u043C, \u0447\u0442\u043E\u0431\u044B \`ctx\` \u0431\u044B\u043B \u0442\u0438\u043F\u0438\u0437\u0438\u0440\u043E\u0432\u0430\u043D:
+ *
+ *   import type { UserStore } from './userStore'
+ *   export const hooks: Hooks<UserStore> = (h) => {
+ *     h.posts.create.after(({ response, ctx }) => { \u2026 })
+ *   }
+ *
+ * (\u041F\u0430\u0440\u0430\u043C\u0435\u0442\u0440 \u041D\u0415 \u0432\u044B\u0432\u043E\u0434\u0438\u0442\u0441\u044F \u0438\u0437 \`ebely.userStore\` \u043D\u0430\u043C\u0435\u0440\u0435\u043D\u043D\u043E: \u044D\u0442\u043E \u0441\u043E\u0437\u0434\u0430\u043B\u043E
+ * \u0431\u044B \u0446\u0438\u043A\u043B \u0442\u0438\u043F\u043E\u0432 \`ebely\` \u21C4 \`Hooks\`, \u0442.\u043A. \`hooks\` \u043B\u0435\u0436\u0438\u0442 \u0432\u043D\u0443\u0442\u0440\u0438 \`ebely\`.)
+ */
+export type Hooks<Store extends BaseStore = BaseStore> = (
+  h: EbelyHookTree<Store>,
+) => void
+
+/**
+ * \u0411\u0430\u0437\u0430 \`World\` \u2014 \u044D\u0442\u043E \u0441\u043A\u043E\u043D\u0444\u0438\u0433\u0443\u0440\u0438\u0440\u043E\u0432\u0430\u043D\u043D\u044B\u0439 \`ebely.worldStore\` (\u0438\u043B\u0438 \u043F\u0443\u0441\u0442\u043E\u0439
+ * \`BaseStore\`, \u0435\u0441\u043B\u0438 \u043D\u0435 \u0437\u0430\u0434\u0430\u043D). \u041F\u043E\u044D\u0442\u043E\u043C\u0443 \`world.<\u0441\u0446\u0435\u043D\u0430\u0440\u0438\u0439>()\` \u0438
+ * \`world.get/set\` \u0434\u043E\u0441\u0442\u0443\u043F\u043D\u044B \u0438 \u0442\u0438\u043F\u0438\u0437\u0438\u0440\u043E\u0432\u0430\u043D\u044B \u0440\u043E\u0432\u043D\u043E \u043A\u0430\u043A \u0443 \u043F\u043E\u043B\u044C\u0437\u043E\u0432\u0430\u0442\u0435\u043B\u044F,
+ * \u0442\u043E\u043B\u044C\u043A\u043E \u043E\u0431\u043B\u0430\u0441\u0442\u044C \u2014 \u0432\u0435\u0441\u044C \u043C\u0438\u0440. \u0422\u0438\u043F \u0431\u0435\u0440\u0451\u0442\u0441\u044F \u0438\u0437 \`ebely\` \u0442\u0435\u043C \u0436\u0435 \u043F\u0440\u0438\u0451\u043C\u043E\u043C, \u0447\u0442\u043E
+ * \u0438 \`Store\` (\u043D\u0438\u043A\u0430\u043A\u0438\u0445 \u0440\u0430\u043D\u0442\u0430\u0439\u043C-\u0443\u0441\u043B\u043E\u0432\u0438\u0439 \u2014 \u0441\u043C. ARCHITECTURE.md \xA78).
+ */
+type ConfiguredWorldStore =
+  typeof ebely extends { worldStore: new () => infer I extends BaseStore }
+    ? I
+    : BaseStore
+const WorldStoreBase = ((ebely as { worldStore?: new () => BaseStore })
+  .worldStore ?? BaseStore) as new () => ConfiguredWorldStore
+
+export class World<
+  Store extends BaseStore = InstanceType<typeof ebely.userStore>,
+> extends WorldStoreBase {
+  /**
+   * \u041E\u0431\u0449\u0438\u0439 \u0440\u0435\u0435\u0441\u0442\u0440 \u0445\u0443\u043A\u043E\u0432. \u0420\u0435\u0433\u0438\u0441\u0442\u0440\u0430\u0446\u0438\u044F \u2014 \u0441\u0442\u0430\u0442\u0438\u0447\u0435\u0441\u043A\u0430\u044F (\u043E\u0434\u0438\u043D \u0440\u0430\u0437 \u0438\u0437 \u043A\u043E\u043D\u0444\u0438\u0433\u0430),
+   * \u043D\u043E \`ctx\` \u043F\u043E\u0434\u0441\u0442\u0430\u0432\u043B\u044F\u0435\u0442\u0441\u044F \u0432 \u043C\u043E\u043C\u0435\u043D\u0442 \u0437\u0430\u043F\u0440\u043E\u0441\u0430 = store \u043A\u043E\u043D\u043A\u0440\u0435\u0442\u043D\u043E\u0433\u043E \u044E\u0437\u0435\u0440\u0430.
+   */
+  private hookRegistry = new HookRegistry()
+
+  constructor(
+    public args: {
+      /** URL \u0431\u044D\u043A\u0435\u043D\u0434\u0430. \u0415\u0441\u043B\u0438 \u043D\u0435 \u0437\u0430\u0434\u0430\u043D \u2014 \u0431\u0435\u0440\u0451\u0442\u0441\u044F ebely.url \u0438\u0437 \u043A\u043E\u043D\u0444\u0438\u0433\u0430. */
+      url?: string
+      /** \u041A\u043B\u0430\u0441\u0441-\u0445\u0440\u0430\u043D\u0438\u043B\u0438\u0449\u0435. \u0415\u0441\u043B\u0438 \u043D\u0435 \u0437\u0430\u0434\u0430\u043D \u2014 \u0431\u0435\u0440\u0451\u0442\u0441\u044F ebely.userStore. */
+      store?: new () => Store
+    } = {},
+  ) {
+    super()
+    const registrar = (ebely as { hooks?: (h: unknown) => void }).hooks
+    if (registrar) registrar(this.buildHookTree())
+    // world-store \u0445\u043E\u0434\u0438\u0442 \u0410\u041D\u041E\u041D\u0418\u041C\u041D\u042B\u041C \u043A\u043B\u0438\u0435\u043D\u0442\u043E\u043C (\u0431\u0435\u0437 per-user \u0437\u0430\u0433\u043E\u043B\u043E\u0432\u043A\u043E\u0432);
+    // ctx \u0445\u0443\u043A\u043E\u0432 \u0434\u043B\u044F \u0442\u0430\u043A\u0438\u0445 \u0432\u044B\u0437\u043E\u0432\u043E\u0432 = \u0441\u0430\u043C world.
+    ;(this as unknown as { api: unknown }).api = this.buildApiTree(
+      this.makeRequest({ headers: {}, store: this }),
+    )
+  }
+
+  /** \u0411\u0430\u0437\u043E\u0432\u044B\u0439 URL \u0441 \u0443\u0447\u0451\u0442\u043E\u043C server.url \u0438\u0437 \u0441\u0445\u0435\u043C\u044B. */
+  private baseUrl(): string {
+    return (this.args.url ?? ebely.url).replace(/\\/$/, '') + ${JSON.stringify(basePath)}
+  }
+
+${renderHookTreeBuilder(groups)}
+
+  /**
+   * \u0421\u043E\u0437\u0434\u0430\u0451\u0442 \`request\`, \u0437\u0430\u043C\u043A\u043D\u0443\u0442\u044B\u0439 \u043D\u0430 \u0437\u0430\u0433\u043E\u043B\u043E\u0432\u043A\u0438 \u0438 \`store\` (\u043E\u043D \u0436\u0435 \`ctx\`
+   * \u0445\u0443\u043A\u043E\u0432). \u041E\u0434\u0438\u043D \u0438 \u0442\u043E\u0442 \u0436\u0435 \u0434\u0432\u0438\u0436\u043E\u043A \u0438 \u0434\u043B\u044F \u043F\u043E\u043B\u044C\u0437\u043E\u0432\u0430\u0442\u0435\u043B\u044F, \u0438 \u0434\u043B\u044F world.
+   */
+  private makeRequest(cfg: {
+    headers: Record<string, string>
+    store: BaseStore
+  }): RequestFn {
+    const baseUrl = this.baseUrl()
+    const registry = this.hookRegistry
+    const { headers: baseHeaders, store } = cfg
+
+    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)),
+        )
+      }
+
+      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}
+    }
+  }
+
+${renderApiTreeBuilder({ groups, mode })}
+
+  /**
+   * \u0421\u043E\u0437\u0434\u0430\u0451\u0442 \xAB\u043F\u043E\u043B\u044C\u0437\u043E\u0432\u0430\u0442\u0435\u043B\u044F\xBB \u2014 \u0438\u0437\u043E\u043B\u0438\u0440\u043E\u0432\u0430\u043D\u043D\u044B\u0439 \u043D\u0430\u0431\u043E\u0440 \u0442\u0438\u043F\u0438\u0437\u0438\u0440\u043E\u0432\u0430\u043D\u043D\u044B\u0445 \u0432\u044B\u0437\u043E\u0432\u043E\u0432
+   * \u044D\u043D\u0434\u043F\u043E\u0438\u043D\u0442\u043E\u0432, \u043A\u043E\u0442\u043E\u0440\u044B\u0439 \u043F\u043E\u0434 \u043A\u0430\u043F\u043E\u0442\u043E\u043C \u0445\u043E\u0434\u0438\u0442 fetch-\u0437\u0430\u043F\u0440\u043E\u0441\u0430\u043C\u0438. \`store.api\`
+   * \u0443\u043A\u0430\u0437\u044B\u0432\u0430\u0435\u0442 \u043D\u0430 \u0442\u043E \u0436\u0435 \u0434\u0435\u0440\u0435\u0432\u043E, \u043F\u043E\u044D\u0442\u043E\u043C\u0443 \u043C\u0435\u0442\u043E\u0434\u044B-\u0441\u0446\u0435\u043D\u0430\u0440\u0438\u0438 \u044D\u0442\u043E\u0433\u043E store
+   * (\`fullRegister\` \u0438 \u0442.\u043F.) \u0445\u043E\u0434\u044F\u0442 \u043E\u0442 \u043B\u0438\u0446\u0430 \u0438\u043C\u0435\u043D\u043D\u043E \u044D\u0442\u043E\u0433\u043E \u043F\u043E\u043B\u044C\u0437\u043E\u0432\u0430\u0442\u0435\u043B\u044F.
+   */
+  createUser(userArgs: CreateUserArgs = {}) {
+    const StoreClass =
+      this.args.store ?? (ebely.userStore as unknown as new () => Store)
+    const store = new StoreClass()
+    const tree = this.buildApiTree(
+      this.makeRequest({ headers: { ...userArgs.headers }, store }),
+    )
+    ;(store as unknown as { api: unknown }).api = tree
+    return Object.assign(store, tree)
+  }
+}
+`;
+}
+
+// src/generator/swagger.ts
+var import_promises = require("fs/promises");
+var import_node_path = require("path");
+async function loadSpec(args) {
+  const { swagger } = args;
+  if (swagger.pathToFile !== void 0) {
+    const specPath = (0, import_node_path.resolve)(process.cwd(), swagger.pathToFile);
+    return JSON.parse(await (0, import_promises.readFile)(specPath, "utf8"));
+  }
+  const response = await fetch(swagger.url);
+  if (!response.ok) {
+    throw new Error(
+      `\u041D\u0435 \u0443\u0434\u0430\u043B\u043E\u0441\u044C \u043F\u043E\u043B\u0443\u0447\u0438\u0442\u044C swagger \u043F\u043E ${swagger.url}: ${response.status} ${response.statusText}`
+    );
+  }
+  return await response.json();
+}
+
+// src/generate-client.ts
+async function generateClient(args) {
+  const {
+    swagger,
+    generateClientTo,
+    mode = "test",
+    userStoreImport = "ebely",
+    configImport = "./ebely"
+  } = args;
+  const outPath = (0, import_node_path2.resolve)(process.cwd(), generateClientTo);
+  const spec = await loadSpec({ swagger });
+  const operations = collectOperations({ spec });
+  const source = renderClient({
+    spec,
+    operations,
+    mode,
+    userStoreImport,
+    configImport
+  });
+  await (0, import_promises2.writeFile)(outPath, source, "utf8");
+  console.log(`
+\u2705 Typed client written to:
+${outPath}
+
+Endpoints: ${operations.length}
+`);
+  return { outPath, operations: operations.length };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ApiResponse,
+  BaseStore,
+  EbelyAssertionError,
+  HookRegistry,
+  generateClient
+});