@rewloy/node 0.1.0

package/dist/client.js

@@ -0,0 +1,404 @@
+/**
+ * The client: credentials, the request (headers, retries, timeouts, errors,
+ * deprecation notices), pagination and streams. The operations themselves
+ * come from the generated RewloyMethods, one method per operationId.
+ */
+import { randomUUID } from 'node:crypto';
+import { RateLimitError, RewloyConnectionError, RewloyError, RewloyTimeoutError } from "./errors.js";
+import { RewloyMethods } from "./generated/methods.js";
+import { ERROR_TITLES, OPERATIONS } from "./generated/operations.js";
+import { EventStream } from "./sse.js";
+import { VERSION } from "./version.js";
+export const DEFAULT_BASE_URL = 'https://app.rewloy.com';
+const DEFAULT_TIMEOUT_MS = 60_000;
+const DEFAULT_MAX_RETRIES = 2;
+const DEFAULT_IDLE_TIMEOUT_MS = 60_000;
+/** Backoff: 0.5 s, 1 s, 2 s… up to 8 s, each with jitter (between half and all of it). */
+const BACKOFF_BASE_MS = 500;
+const BACKOFF_MAX_MS = 8000;
+/** A `Retry-After` longer than this is not waited for: the error goes to the caller. */
+const MAX_RETRY_AFTER_MS = 60_000;
+/** setTimeout's ceiling; a longer (or infinite) timeout means none. */
+const MAX_TIMER_MS = 2 ** 31 - 1;
+const IDEMPOTENT_METHODS = new Set(['GET', 'HEAD', 'PUT', 'DELETE']);
+/** 502–504 and Cloudflare's 520–524 (the origin unreachable or too slow). */
+const GATEWAY_STATUSES = new Set([502, 503, 504, 520, 521, 522, 523, 524]);
+/** Operations already warned about: one warning per operation per process. */
+const warned = new Set();
+const defaultSleep = (ms, signal) => new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+        reject(signal.reason);
+        return;
+    }
+    const onAbort = () => {
+        clearTimeout(timer);
+        reject(signal.reason);
+    };
+    const timer = setTimeout(() => {
+        signal?.removeEventListener('abort', onAbort);
+        resolve();
+    }, ms);
+    signal?.addEventListener('abort', onAbort, { once: true });
+});
+const isRecord = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+/** `Retry-After` in milliseconds: delta-seconds or an HTTP date. */
+export function parseRetryAfter(value, now = Date.now()) {
+    if (!value)
+        return null;
+    const v = value.trim();
+    if (/^\d+(\.\d+)?$/.test(v))
+        return Math.round(Number(v) * 1000);
+    const at = Date.parse(v);
+    return Number.isNaN(at) ? null : Math.max(0, at - now);
+}
+/** Exponential backoff with jitter for the retry after attempt `attempt` (0-based). */
+export function backoff(attempt, random = Math.random) {
+    const cap = Math.min(BACKOFF_MAX_MS, BACKOFF_BASE_MS * 2 ** attempt);
+    return Math.round(cap / 2 + random() * (cap / 2));
+}
+/** The URL a `Link` header gives for `rel="deprecation"` (else its first). */
+function deprecationLink(link) {
+    if (!link)
+        return null;
+    let first = null;
+    for (const m of link.matchAll(/<([^>]*)>([^,]*)/g)) {
+        first ??= m[1];
+        if (/\brel\s*=\s*"?[^";]*\bdeprecation\b/i.test(m[2]))
+            return m[1];
+    }
+    return first;
+}
+function warn(message) {
+    const p = globalThis.process;
+    if (typeof p?.emitWarning !== 'function') {
+        console.warn(`DeprecationWarning: ${message}`);
+        return;
+    }
+    try {
+        p.emitWarning(message, { type: 'DeprecationWarning', code: 'REWLOY_DEPRECATED' });
+    }
+    catch (err) {
+        // `node --throw-deprecation` throws here: let it surface, not pass for a failed request.
+        queueMicrotask(() => { throw err; });
+    }
+}
+function userAgent(suffix) {
+    const node = globalThis.process?.versions?.node;
+    // A browser decides its own User-Agent, and the API's CORS allow-list has no room for it.
+    if (!node)
+        return null;
+    return [`rewloy-node/${VERSION}`, `node/${node}`, suffix?.trim()].filter(Boolean).join(' ');
+}
+/**
+ * A client of the Rewloy API (`https://app.rewloy.com/v1`).
+ *
+ * ```ts
+ * const rewloy = new Rewloy({ apiKey: process.env.REWLOY_API_KEY! });
+ * const card = await rewloy.getPass({ params: { serial: 'ABCD-EFGH-JKLM' } });
+ * ```
+ *
+ * Every operation of the API is a method named by its operationId; each takes
+ * one argument with `params`, `query` and `body` as the operation needs, and
+ * the options of {@link RequestOptions}.
+ */
+export class Rewloy extends RewloyMethods {
+    baseUrl;
+    timeoutMs;
+    maxRetries;
+    /** The kind of credential this client sends, or `null` for none. */
+    credential;
+    /** The default `Rewloy-Merchant` of a staff session. */
+    merchant;
+    #token;
+    #fetch;
+    #userAgent;
+    #sleep;
+    constructor(options = {}) {
+        super();
+        const given = ['apiKey', 'staffSession', 'holderSession'].filter((k) => options[k] !== undefined);
+        if (given.length > 1)
+            throw new TypeError(`Rewloy: give one credential, not ${given.join(' and ')}`);
+        const prefixes = { apiKey: ['rwk_', 'key'], staffSession: ['rws_', 'staff'], holderSession: ['rwh_', 'holder'] };
+        const which = given[0];
+        if (which) {
+            const token = options[which];
+            const [prefix, kind] = prefixes[which];
+            if (typeof token !== 'string' || !token.startsWith(prefix))
+                throw new TypeError(`Rewloy: ${which} must start with "${prefix}"`);
+            this.#token = token;
+            this.credential = kind;
+        }
+        else {
+            this.#token = null;
+            this.credential = null;
+        }
+        if (options.merchant !== undefined && which !== 'staffSession')
+            throw new TypeError('Rewloy: `merchant` goes with a staffSession');
+        this.merchant = options.merchant ?? null;
+        this.baseUrl = (options.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, '');
+        this.timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+        this.maxRetries = options.maxRetries ?? DEFAULT_MAX_RETRIES;
+        const f = options.fetch ?? globalThis.fetch;
+        if (typeof f !== 'function')
+            throw new TypeError('Rewloy: no fetch (Node 22 or later has one)');
+        this.#fetch = options.fetch ? f : (input, init) => globalThis.fetch(input, init);
+        this.#userAgent = userAgent(options.userAgent);
+        this.#sleep = options.sleep ?? defaultSleep;
+    }
+    /**
+     * Calls an operation and returns the whole answer: `data`, `meta` on paged
+     * lists, the status, headers, `requestId`, `mode` and `replayed`.
+     *
+     * ```ts
+     * const res = await rewloy.request('sendCampaign', { body: { body: 'Bu hafta kahveler 2 damga!' } });
+     * res.status; res.replayed; res.data.id;
+     * ```
+     */
+    async request(id, ...args) {
+        const op = this.#operation(id);
+        if (op.stream)
+            throw new TypeError(`Rewloy: ${id} is a stream; use stream('${id}')`);
+        const { res, data, meta } = await this.#exchange(id, op, args[0]);
+        return {
+            data: data, meta, status: res.status, headers: res.headers,
+            requestId: res.headers.get('x-request-id'), mode: res.headers.get('rewloy-mode'),
+            replayed: res.headers.get('idempotent-replayed') === 'true',
+        };
+    }
+    /**
+     * Walks a paged list item by item, asking for the next page (`page`) while
+     * `meta` says there is one. `query.page` sets where to start and
+     * `query.limit` the page size.
+     *
+     * ```ts
+     * for await (const customer of rewloy.paginate('listCustomers', { query: { consent: 'yes' } })) { … }
+     * ```
+     */
+    paginate(id, ...args) {
+        const op = this.#operation(id);
+        if (!op.paged)
+            throw new TypeError(`Rewloy: ${id} is not a paged list`);
+        const base = (args[0] ?? {});
+        const exchange = (page) => this.#exchange(id, op, { ...base, query: { ...base.query, page } });
+        return (async function* () {
+            let page = Number(base.query?.page ?? 1);
+            for (;;) {
+                const { data, meta } = await exchange(page);
+                const items = (Array.isArray(data) ? data : []);
+                yield* items;
+                if (!meta || items.length === 0 || items.length < meta.pageSize || meta.page * meta.pageSize >= meta.total)
+                    return;
+                page = meta.page + 1;
+            }
+        })();
+    }
+    /**
+     * Opens a server-sent event stream (`liveFeed`, `holderCardEvents`) and
+     * iterates its events. It reconnects by itself unless `reconnect: false`;
+     * stop it with `signal`, `break` or `close()`.
+     *
+     * ```ts
+     * for await (const ev of rewloy.stream('liveFeed', { signal })) {
+     *   if (ev.event === 'event') console.log(JSON.parse(ev.data));
+     * }
+     * ```
+     */
+    stream(id, ...args) {
+        return this.#open(id, args[0]);
+    }
+    async _call(id, args) {
+        const op = this.#operation(id);
+        const { data, meta } = await this.#exchange(id, op, args);
+        return (op.paged ? { data, meta } : data);
+    }
+    _open(id, args) {
+        return this.#open(id, args);
+    }
+    #open(id, args) {
+        const op = this.#operation(id);
+        if (!op.stream)
+            throw new TypeError(`Rewloy: ${id} is not a stream; use request('${id}')`);
+        const a = args ?? {};
+        return new EventStream({
+            operation: id,
+            connect: async (lastEventId, controller) => (await this.#exchange(id, op, a, { lastEventId, controller })).res,
+            signal: a.signal,
+            reconnect: a.reconnect ?? true,
+            idleTimeoutMs: a.idleTimeoutMs ?? DEFAULT_IDLE_TIMEOUT_MS,
+            sleep: this.#sleep,
+        });
+    }
+    #operation(id) {
+        const op = Object.hasOwn(OPERATIONS, id) ? OPERATIONS[id] : undefined;
+        if (!op)
+            throw new TypeError(`Rewloy: unknown operation "${String(id)}"`);
+        return op;
+    }
+    #url(id, op, a) {
+        const path = op.path.replace(/\{([^}]+)\}/g, (_m, name) => {
+            const v = a.params?.[name];
+            if (v === undefined || v === null || v === '')
+                throw new TypeError(`Rewloy: ${id} needs params.${name}`);
+            return encodeURIComponent(String(v));
+        });
+        const query = new URLSearchParams();
+        for (const [k, v] of Object.entries(a.query ?? {})) {
+            if (v === undefined || v === null)
+                continue;
+            for (const x of Array.isArray(v) ? v : [v])
+                query.append(k, String(x));
+        }
+        const qs = query.toString();
+        return `${this.baseUrl}${path}${qs ? `?${qs}` : ''}`;
+    }
+    #headers(op, a, lastEventId) {
+        const h = new Headers();
+        h.set('accept', op.stream ? 'text/event-stream' : op.response === 'json' || op.response === 'raw-json' ? 'application/json' : '*/*');
+        if (this.#userAgent)
+            h.set('user-agent', this.#userAgent);
+        // An operation that takes no credential of this kind but works without one is called without it:
+        // the API refuses a credential an operation does not accept (CREDENTIAL_NOT_ALLOWED).
+        if (this.#token && this.credential && (op.auth.includes(this.credential) || !op.auth.includes('public'))) {
+            h.set('authorization', `Bearer ${this.#token}`);
+        }
+        const merchant = a.merchant ?? (this.credential === 'staff' ? this.merchant : null);
+        if (op.merchant && merchant)
+            h.set('rewloy-merchant', merchant);
+        if (op.idempotency)
+            h.set('idempotency-key', a.idempotencyKey ?? randomUUID());
+        if (op.body)
+            h.set('content-type', 'application/json');
+        if (lastEventId)
+            h.set('last-event-id', lastEventId);
+        for (const [k, v] of Object.entries(a.headers ?? {}))
+            if (v !== undefined && v !== null)
+                h.set(k, String(v));
+        return h;
+    }
+    #notice(id, op, headers) {
+        if (!headers.has('deprecation') || warned.has(id))
+            return;
+        warned.add(id);
+        const sunset = headers.get('sunset');
+        const link = deprecationLink(headers.get('link'));
+        warn(`Rewloy API operation ${id} (${op.method} ${op.path}) is deprecated.${sunset ? ` Sunset: ${sunset}.` : ''}${link ? ` See ${link}` : ''}`);
+    }
+    /**
+     * One call: attempts until an answer settles it. For a stream it resolves
+     * once the headers are in, the body unread; otherwise with the body read.
+     */
+    async #exchange(id, op, args, stream) {
+        const a = args ?? {};
+        const url = this.#url(id, op, a);
+        const headers = this.#headers(op, a, stream?.lastEventId);
+        const body = op.body ? JSON.stringify(a.body ?? {}) : undefined;
+        const retryable = IDEMPOTENT_METHODS.has(op.method) || headers.has('idempotency-key');
+        const maxRetries = Math.max(0, a.maxRetries ?? this.maxRetries);
+        const timeoutMs = a.timeoutMs ?? this.timeoutMs;
+        const signal = a.signal;
+        for (let attempt = 0;; attempt++) {
+            signal?.throwIfAborted();
+            const attemptCtrl = new AbortController();
+            let timedOut = false;
+            const timer = timeoutMs > 0 && timeoutMs < MAX_TIMER_MS ? setTimeout(() => { timedOut = true; attemptCtrl.abort(); }, timeoutMs) : undefined;
+            const signals = [attemptCtrl.signal, ...(signal ? [signal] : []), ...(stream ? [stream.controller.signal] : [])];
+            let failure;
+            let wait = null;
+            try {
+                const res = await this.#fetch(url, { method: op.method, headers, body, signal: AbortSignal.any(signals) });
+                this.#notice(id, op, res.headers);
+                if (res.ok) {
+                    if (stream)
+                        return { res, data: undefined, meta: undefined };
+                    return { res, ...(await this.#read(id, op, res)) };
+                }
+                failure = this.#failure(id, res, await res.text().catch(() => ''));
+                const retryAfter = parseRetryAfter(res.headers.get('retry-after'));
+                if (!retryable || attempt >= maxRetries || !this.#retryStatus(res.status, failure.code))
+                    throw failure;
+                wait = retryAfter;
+            }
+            catch (err) {
+                if (err instanceof RewloyError)
+                    throw err;
+                if (signal?.aborted)
+                    throw signal.reason;
+                if (stream?.controller.signal.aborted)
+                    throw err;
+                failure = timedOut
+                    ? new RewloyTimeoutError({ detail: `no answer within ${String(timeoutMs)} ms`, operation: id, cause: err })
+                    : new RewloyConnectionError({ detail: describe(err), operation: id, cause: err });
+                if (!retryable || attempt >= maxRetries)
+                    throw failure;
+            }
+            finally {
+                // For a stream the timer ends with the headers; the body is the stream's own business.
+                clearTimeout(timer);
+            }
+            const delay = wait ?? backoff(attempt);
+            if (delay > MAX_RETRY_AFTER_MS)
+                throw failure;
+            await this.#sleep(delay, signal);
+            signal?.throwIfAborted();
+        }
+    }
+    #retryStatus(status, code) {
+        return status === 429 || GATEWAY_STATUSES.has(status) || (status === 409 && code === 'IDEMPOTENCY_IN_PROGRESS');
+    }
+    async #read(id, op, res) {
+        if (op.response === 'none' || res.status === 204) {
+            await res.arrayBuffer().catch(() => undefined);
+            return { data: undefined, meta: undefined };
+        }
+        if (op.response === 'blob')
+            return { data: await res.blob(), meta: undefined };
+        const text = await res.text();
+        let parsed;
+        try {
+            parsed = JSON.parse(text);
+        }
+        catch {
+            throw this.#invalid(id, res, text);
+        }
+        if (op.response === 'raw-json')
+            return { data: parsed, meta: undefined };
+        if (!isRecord(parsed) || !('data' in parsed))
+            throw this.#invalid(id, res, parsed);
+        return { data: parsed.data, meta: isRecord(parsed.meta) ? parsed.meta : undefined };
+    }
+    #invalid(id, res, body) {
+        return new RewloyError({
+            status: res.status, code: 'INVALID_RESPONSE', detail: `the answer is not the JSON the API documents (${res.headers.get('content-type') ?? 'no content type'})`,
+            requestId: res.headers.get('x-request-id'), body, headers: res.headers, operation: id,
+        });
+    }
+    #failure(id, res, text) {
+        let parsed = text;
+        try {
+            parsed = text ? JSON.parse(text) : null;
+        }
+        catch { /* not JSON: a proxy's page */ }
+        const e = isRecord(parsed) && isRecord(parsed.error) ? parsed.error : null;
+        const code = e && typeof e.code === 'string' ? e.code : `HTTP_${String(res.status)}`;
+        const init = {
+            status: res.status, code,
+            title: Object.hasOwn(ERROR_TITLES, code) ? ERROR_TITLES[code] : null,
+            detail: e && typeof e.message === 'string' ? e.message : res.statusText || `HTTP ${String(res.status)}`,
+            details: e?.details, docs: e && typeof e.docs === 'string' ? e.docs : null,
+            requestId: res.headers.get('x-request-id') ?? (e && typeof e.requestId === 'string' ? e.requestId : null),
+            body: parsed, headers: res.headers, operation: id,
+        };
+        if (res.status === 429) {
+            const header = parseRetryAfter(res.headers.get('retry-after'));
+            const fromBody = isRecord(init.details) && typeof init.details.retryAfterSec === 'number' ? init.details.retryAfterSec : null;
+            return new RateLimitError({ ...init, retryAfter: header !== null ? Math.ceil(header / 1000) : fromBody });
+        }
+        return new RewloyError(init);
+    }
+}
+function describe(err) {
+    if (!(err instanceof Error))
+        return String(err);
+    const cause = err.cause instanceof Error ? err.cause.message : undefined;
+    return cause ? `${err.message}: ${cause}` : err.message;
+}

package/dist/errors.d.ts

@@ -0,0 +1,73 @@
+/**
+ * What the client throws. Every failure to get an answer from Rewloy is a
+ * RewloyError: an error answer from the API (with its stable `code`), an
+ * answer that is not what the API documents, or no answer at all.
+ */
+import type { ErrorCode } from './generated/types.js';
+export interface RewloyErrorInit {
+    status: number;
+    code: string;
+    detail: string;
+    title?: string | null | undefined;
+    details?: unknown;
+    docs?: string | null | undefined;
+    requestId?: string | null | undefined;
+    body?: unknown;
+    headers?: Headers | null | undefined;
+    operation?: string | null | undefined;
+    cause?: unknown;
+}
+/**
+ * The API answered with an error, or the call failed on the way.
+ *
+ * Act on `code`: it is stable, while `detail` is a human sentence in Turkish
+ * that may change. Besides the API's codes (https://rewloy.com/gelistiriciler/hatalar)
+ * the client uses:
+ *   - `CONNECTION_ERROR` and `TIMEOUT` (status 0): no answer arrived;
+ *   - `INVALID_RESPONSE`: a 2xx answer that is not the documented JSON;
+ *   - `HTTP_<status>`: an error answer without Rewloy's error body (a proxy's 502 page).
+ */
+export declare class RewloyError extends Error {
+    /** The HTTP status; 0 when no answer arrived. */
+    readonly status: number;
+    /** The API's stable machine code, e.g. `INSUFFICIENT_BALANCE`. */
+    readonly code: ErrorCode | (string & {});
+    /** The code's one-line title in the catalogue, e.g. "Bakiye yetersiz". */
+    readonly title: string | null;
+    /** What happened, in the API's words (`error.message`). */
+    readonly detail: string;
+    /**
+     * The API's `error.details`, when it sent any: for `VALIDATION` a list of
+     * `{ field, rule, message }`, for others what the catalogue says (`left`,
+     * `channels`, `request`…).
+     */
+    readonly details: unknown;
+    /** Where the catalogue explains the code (`error.docs`). */
+    readonly docs: string | null;
+    /** `x-request-id`: quote it to Rewloy support. */
+    readonly requestId: string | null;
+    /** The parsed answer body (or its text, when it is not JSON). */
+    readonly body: unknown;
+    readonly headers: Headers | null;
+    /** The operationId of the call. */
+    readonly operation: string | null;
+    constructor(init: RewloyErrorInit);
+}
+/** 429 `RATE_LIMITED`: too many requests for this credential or this action. */
+export declare class RateLimitError extends RewloyError {
+    /** Seconds to wait before trying again (`Retry-After`), when the API said. */
+    readonly retryAfter: number | null;
+    constructor(init: RewloyErrorInit & {
+        retryAfter: number | null;
+    });
+}
+/** No answer arrived: the connection failed or broke (`CONNECTION_ERROR`). */
+export declare class RewloyConnectionError extends RewloyError {
+    constructor(init: Omit<RewloyErrorInit, 'status' | 'code'> & {
+        code?: string;
+    });
+}
+/** No answer within `timeoutMs` (`TIMEOUT`), or a stream fell silent. */
+export declare class RewloyTimeoutError extends RewloyConnectionError {
+    constructor(init: Omit<RewloyErrorInit, 'status' | 'code'>);
+}

package/dist/errors.js

@@ -0,0 +1,81 @@
+/**
+ * What the client throws. Every failure to get an answer from Rewloy is a
+ * RewloyError: an error answer from the API (with its stable `code`), an
+ * answer that is not what the API documents, or no answer at all.
+ */
+/**
+ * The API answered with an error, or the call failed on the way.
+ *
+ * Act on `code`: it is stable, while `detail` is a human sentence in Turkish
+ * that may change. Besides the API's codes (https://rewloy.com/gelistiriciler/hatalar)
+ * the client uses:
+ *   - `CONNECTION_ERROR` and `TIMEOUT` (status 0): no answer arrived;
+ *   - `INVALID_RESPONSE`: a 2xx answer that is not the documented JSON;
+ *   - `HTTP_<status>`: an error answer without Rewloy's error body (a proxy's 502 page).
+ */
+export class RewloyError extends Error {
+    /** The HTTP status; 0 when no answer arrived. */
+    status;
+    /** The API's stable machine code, e.g. `INSUFFICIENT_BALANCE`. */
+    code;
+    /** The code's one-line title in the catalogue, e.g. "Bakiye yetersiz". */
+    title;
+    /** What happened, in the API's words (`error.message`). */
+    detail;
+    /**
+     * The API's `error.details`, when it sent any: for `VALIDATION` a list of
+     * `{ field, rule, message }`, for others what the catalogue says (`left`,
+     * `channels`, `request`…).
+     */
+    details;
+    /** Where the catalogue explains the code (`error.docs`). */
+    docs;
+    /** `x-request-id`: quote it to Rewloy support. */
+    requestId;
+    /** The parsed answer body (or its text, when it is not JSON). */
+    body;
+    headers;
+    /** The operationId of the call. */
+    operation;
+    constructor(init) {
+        const where = [init.operation, init.requestId ? `requestId ${init.requestId}` : null].filter(Boolean).join(', ');
+        super(`${init.status ? `${String(init.status)} ` : ''}${init.code}: ${init.detail}${where ? ` (${where})` : ''}`, init.cause === undefined ? undefined : { cause: init.cause });
+        this.status = init.status;
+        this.code = init.code;
+        this.title = init.title ?? null;
+        this.detail = init.detail;
+        this.details = init.details;
+        this.docs = init.docs ?? null;
+        this.requestId = init.requestId ?? null;
+        this.body = init.body;
+        this.headers = init.headers ?? null;
+        this.operation = init.operation ?? null;
+    }
+}
+/** 429 `RATE_LIMITED`: too many requests for this credential or this action. */
+export class RateLimitError extends RewloyError {
+    /** Seconds to wait before trying again (`Retry-After`), when the API said. */
+    retryAfter;
+    constructor(init) {
+        super(init);
+        this.retryAfter = init.retryAfter;
+    }
+}
+/** No answer arrived: the connection failed or broke (`CONNECTION_ERROR`). */
+export class RewloyConnectionError extends RewloyError {
+    constructor(init) {
+        super({ ...init, status: 0, code: init.code ?? 'CONNECTION_ERROR' });
+    }
+}
+/** No answer within `timeoutMs` (`TIMEOUT`), or a stream fell silent. */
+export class RewloyTimeoutError extends RewloyConnectionError {
+    constructor(init) {
+        super({ ...init, code: 'TIMEOUT' });
+    }
+}
+// On the prototypes, not as fields: the stack trace's first line is written
+// while the base constructor runs, before a field would be set.
+const names = [[RewloyError, 'RewloyError'], [RateLimitError, 'RateLimitError'],
+    [RewloyConnectionError, 'RewloyConnectionError'], [RewloyTimeoutError, 'RewloyTimeoutError']];
+for (const [E, name] of names)
+    Object.defineProperty(E.prototype, 'name', { value: name, writable: true, configurable: true });