tempest-react-sdk 0.78.0 → 0.80.0

package/dist/http/describe-api-error.js.map

@@ -1 +1 @@
-{"version":3,"file":"describe-api-error.js","names":[],"sources":["../../src/http/describe-api-error.ts"],"sourcesContent":["// The last mile of error handling: a typed error is what code reads, a sentence\n// is what a person reads, and every app was writing the funnel between the two.\n// The case everyone forgets is the request that never reached the server, which\n// without special handling renders as the nonsense \"erro 0\".\n\nimport { isApiError, syntheticDetail } from \"./errors\";\n\n/** The fixed sentences {@link describeApiError} may need. */\nexport interface ApiErrorStrings {\n    /** Shown when the request never reached the server. */\n    offline: string;\n    /**\n     * Shown when the backend rejected the payload field by field.\n     *\n     * The per-field messages are on `error.fields`, to be attached to the inputs\n     * themselves; this sentence is what the toast says.\n     *\n     * It does not apply to the one rejection that named a single field with a\n     * finished sentence — there the server's own `detail` is shown instead, since\n     * it is the same string `fields` carries. Pass `useDetail: false` to force\n     * this sentence in that case too.\n     */\n    validation: string;\n}\n\n/**\n * PT-BR defaults, used when no strings are supplied and no catalog answers.\n *\n * The SDK's copy is pt-BR everywhere else (`FilterBar`, `DataTable`, `Chat`), so\n * the default here matches rather than introducing an English string that only\n * shows up on a network failure.\n */\nexport const DEFAULT_API_ERROR_STRINGS: ApiErrorStrings = {\n    offline: \"Sem conexão com o servidor. Verifique sua internet e tente de novo.\",\n    validation: \"Confira os campos destacados e tente de novo.\",\n};\n\n/**\n * Translation key the {@link useDescribeApiError} hook looks up.\n *\n * A catalog that does not define it falls back to\n * {@link DEFAULT_API_ERROR_STRINGS}, because `t` returns the key itself when the\n * lookup misses and printing `tempest.error.offline` at the user would be worse\n * than printing pt-BR at them.\n */\nexport const API_ERROR_OFFLINE_KEY = \"tempest.error.offline\";\n\n/**\n * Translation key for the validation sentence, looked up the same way as\n * {@link API_ERROR_OFFLINE_KEY}.\n */\nexport const API_ERROR_VALIDATION_KEY = \"tempest.error.validation\";\n\n/**\n * Everything {@link describeApiError} accepts beyond the error and the fallback.\n *\n * Extends the fixed sentences rather than sitting beside them, so a caller that\n * already passed `{ offline, validation }` keeps compiling untouched.\n */\nexport interface DescribeApiErrorOptions extends Partial<ApiErrorStrings> {\n    /**\n     * Maps the backend's programmatic `code` to a sentence in your language.\n     *\n     * The client already surfaces `code` on `ApiError`, but without this every\n     * app writes the same `switch` over it. A hit here wins over every other\n     * step: it is the only sentence written for that exact case, by someone who\n     * knew both the backend contract and the screen it lands on.\n     */\n    codes?: Readonly<Record<string, string>>;\n    /**\n     * Maps an HTTP status to a sentence, for the failures that arrive with no\n     * useful body.\n     *\n     * `codes` covers the cases the backend named; this covers the ones it did\n     * not. The reference case is the `403` of an admin-only route: the body\n     * carries a generic `detail` (or none), so the funnel fell through to the\n     * fallback and an administrator read \"Não foi possível carregar\" when the\n     * fact that answers their question is \"esta listagem é só para\n     * administradores\".\n     *\n     * Checked after `codes` and **before** the backend's `detail`: a generic\n     * sentence emitted by the framework is worse than the one the app wrote for\n     * that status. `useDetail: false` remains the way to suppress `detail`\n     * entirely.\n     *\n     * A `0` key is honoured like any other, ahead of the offline sentence —\n     * `statuses` is the caller's explicit map, and the fixed `offline` string is\n     * already the way to reword that case. Status `0` covers a request that\n     * never landed **and** one abandoned by the client timeout, so an app that\n     * maps it is taking both.\n     */\n    statuses?: Readonly<Record<number, string>>;\n    /**\n     * Whether the backend's `detail` may be shown when no `code` matched.\n     * Default `true`.\n     *\n     * Set it to `false` when `detail` is written for developers rather than\n     * users, or when it could echo internals — the result is then always either\n     * a sentence you wrote or the fallback.\n     */\n    useDetail?: boolean;\n}\n\n/**\n * Whether the browser currently reports itself as offline.\n *\n * `fetch` rejects a network failure with a plain `TypeError` whose message\n * differs per browser (\"Failed to fetch\", \"NetworkError when attempting to fetch\n * resource.\", \"Load failed\"), so sniffing the message is not portable. The online\n * flag is, and it is the signal that matters for the sentence being chosen.\n *\n * @returns `true` only when the environment positively says it is offline.\n */\nfunction browserIsOffline(): boolean {\n    return typeof navigator !== \"undefined\" && navigator.onLine === false;\n}\n\n/**\n * Whether `fields` is the flattened single-field envelope, carrying `detail`.\n *\n * The check is identity rather than shape-sniffing. `collectFields` has exactly\n * two sources: FastAPI's `detail` **list**, whose entries are the per-issue\n * messages, and the flattened envelope, whose one entry is built from the same\n * string that becomes `ApiError.detail`. So one entry equal to `detail` can only\n * have come from the second, and returning `detail` there shows the string the\n * form is already about to attach to that input.\n *\n * @param fields - The error's field messages.\n * @param detail - `error.detail`, already trimmed.\n * @param status - The HTTP status, to recognise the synthetic `Erro <status>`\n *     that stands in when the body carried no message at all.\n * @returns Whether `detail` is safe to show as the sentence.\n */\nfunction singleFieldSentence(\n    fields: Record<string, string>,\n    detail: string,\n    status: number,\n): boolean {\n    if (detail === \"\" || detail === syntheticDetail(status)) return false;\n    const messages = Object.values(fields);\n    return messages.length === 1 && messages[0].trim() === detail;\n}\n\n/**\n * Turn any caught value into a sentence worth showing.\n *\n * The funnel, in order:\n *\n * 0. `codes[error.code]` — the sentence you wrote for that exact backend case.\n *    Checked first because nothing the funnel derives can beat it, and because a\n *    request that never landed carries no `code` for it to shadow.\n * 0.5. `statuses[error.status]` — the sentence for a whole class of failure,\n *    for the errors that arrive with no useful body. It beats the backend's\n *    `detail`, because a generic line emitted by the framework is worse than the\n *    one the app wrote for that status, and it beats the offline sentence when\n *    the caller maps `0` explicitly.\n * 1. A request that never reached the server — `status === 0`, or a non-API\n *    error thrown while the browser reports itself offline — produces the\n *    offline sentence. This is the step apps skip, and skipping it renders\n *    \"erro 0\" or a raw `TypeError` at the user.\n * 2. A validation rejection — `error.fields` is set — produces the validation\n *    sentence, **not** `detail`. On a FastAPI `422` the `detail` line is assembled\n *    from the backend's field paths and the validator's own wording\n *    (`\"items.0.price: Input should be greater than 0\"`), which is right for a\n *    log and wrong for a person: it is half English in a pt-BR screen and it\n *    names internals. The per-field messages stay on `fields`, where a form can\n *    attach them to the inputs that failed.\n *\n *    **Unless the rejection named exactly one field and its message is\n *    `detail` itself**, in which case `detail` is returned. That is not a guess\n *    about the text: `collectFields` fills a single entry from `detail` only for\n *    the flattened envelope a `tempest-fastapi-sdk` backend sends, where the\n *    server wrote one finished sentence about one field (`\"CPF ou CNPJ\n *    inválido\"`). Returning it shows the same string that is already on\n *    `fields`, so nothing is invented and nothing is lost. The assembled FastAPI\n *    line never reaches this branch, because it comes from the `detail` **list**\n *    and its entries are the per-issue messages, not `detail`.\n *\n *    This is a fix, not a preference. Before `namedField` shipped in 0.54.0,\n *    `fields` was empty against that backend and the sentence reached the user\n *    through step 3; filling `fields` silently replaced it with \"Confira os\n *    campos destacados\", which presumes a screen that highlights fields — and\n *    no app highlighted anything on the day of the bump.\n *\n *    `useDetail: false` still suppresses it, and is the way to force the fixed\n *    sentence for a backend whose text is written for developers. `validation`\n *    does **not** override it, and that is on purpose: its own contract is the\n *    sentence for a payload rejected *field by field*, which one field carrying\n *    one finished sentence is not — and `useDescribeApiError` always passes\n *    `validation`, so treating it as an override would mean the branch never ran\n *    for any component, which is every caller that matters here.\n * 3. The backend's own `detail`, which is the most specific thing available and\n *    is already written for a person — unless `useDetail: false` says that text\n *    is for developers.\n * 4. `fallback`, with `(HTTP <status>)` appended when a status is known, so the\n *    screenshot in the support ticket carries the one fact a developer needs.\n *\n * Pure on purpose: it works in an interceptor, in a logger and anywhere outside\n * the React tree. {@link useDescribeApiError} is the same funnel with the\n * sentences resolved through `I18nProvider`.\n *\n * @example\n * catch (error) {\n *     toast(describeApiError(error, \"Não foi possível salvar o pedido\"));\n * }\n *\n * @example\n * catch (error) {\n *     toast(\n *         describeApiError(error, \"Não foi possível se candidatar\", {\n *             codes: {\n *                 SERVICE_FULL: \"Este serviço atingiu o limite de vagas.\",\n *                 CANDIDATE_ALREADY_EXISTS: \"Você já se candidatou a este serviço.\",\n *             },\n *             useDetail: false,\n *         }),\n *     );\n * }\n *\n * @param error - The caught value, of any shape.\n * @param fallback - What to say when the error carries nothing better.\n * @param options - A `codes` catalog, `useDetail`, and overrides for the fixed\n *     sentences.\n * @returns A sentence to show the user.\n */\nexport function describeApiError(\n    error: unknown,\n    fallback: string,\n    options?: DescribeApiErrorOptions,\n): string {\n    const offline = options?.offline ?? DEFAULT_API_ERROR_STRINGS.offline;\n\n    if (isApiError(error)) {\n        const mapped = error.code === undefined ? undefined : options?.codes?.[error.code];\n        if (mapped !== undefined) return mapped;\n        const byStatus = options?.statuses?.[error.status];\n        if (byStatus !== undefined) return byStatus;\n        if (error.status === 0) return offline;\n        const detail = error.detail.trim();\n        if (error.fields && Object.keys(error.fields).length > 0) {\n            if (\n                options?.useDetail !== false &&\n                singleFieldSentence(error.fields, detail, error.status)\n            ) {\n                return detail;\n            }\n            return options?.validation ?? DEFAULT_API_ERROR_STRINGS.validation;\n        }\n        if (\n            options?.useDetail !== false &&\n            detail !== \"\" &&\n            detail !== syntheticDetail(error.status)\n        ) {\n            return detail;\n        }\n        return `${fallback} (HTTP ${error.status})`;\n    }\n\n    if (browserIsOffline()) return offline;\n\n    return fallback;\n}\n"],"mappings":";;AAgCA,IAAa,IAA6C;CACtD,SAAS;CACT,YAAY;AAChB,GAUa,IAAwB,yBAMxB,IAA2B;AA8DxC,SAAS,IAA4B;CACjC,OAAO,OAAO,YAAc,OAAe,UAAU,WAAW;AACpE;AAkBA,SAAS,EACL,GACA,GACA,GACO;CACP,IAAI,MAAW,MAAM,MAAW,EAAgB,CAAM,GAAG,OAAO;CAChE,IAAM,IAAW,OAAO,OAAO,CAAM;CACrC,OAAO,EAAS,WAAW,KAAK,EAAS,EAAE,CAAC,KAAK,MAAM;AAC3D;AAoFA,SAAgB,EACZ,GACA,GACA,GACM;CACN,IAAM,IAAU,GAAS,WAAW,EAA0B;CAE9D,IAAI,EAAW,CAAK,GAAG;EACnB,IAAM,IAAS,EAAM,SAAS,KAAA,IAAY,KAAA,IAAY,GAAS,QAAQ,EAAM;EAC7E,IAAI,MAAW,KAAA,GAAW,OAAO;EACjC,IAAM,IAAW,GAAS,WAAW,EAAM;EAC3C,IAAI,MAAa,KAAA,GAAW,OAAO;EACnC,IAAI,EAAM,WAAW,GAAG,OAAO;EAC/B,IAAM,IAAS,EAAM,OAAO,KAAK;EAiBjC,OAhBI,EAAM,UAAU,OAAO,KAAK,EAAM,MAAM,CAAC,CAAC,SAAS,IAE/C,GAAS,cAAc,MACvB,EAAoB,EAAM,QAAQ,GAAQ,EAAM,MAAM,IAE/C,IAEJ,GAAS,cAAc,EAA0B,aAGxD,GAAS,cAAc,MACvB,MAAW,MACX,MAAW,EAAgB,EAAM,MAAM,IAEhC,IAEJ,GAAG,EAAS,SAAS,EAAM,OAAO;CAC7C;CAIA,OAFI,EAAiB,IAAU,IAExB;AACX"}
+{"version":3,"file":"describe-api-error.js","names":["DEFAULT_API_ERROR_STRINGS","API_ERROR_OFFLINE_KEY","API_ERROR_VALIDATION_KEY","browserIsOffline","singleFieldSentence","detail","syntheticDetail","status","messages","fields","describeApiError","offline","options","isApiError","error","mapped","byStatus","fallback"],"sources":["../../src/http/describe-api-error.ts"],"sourcesContent":["// The last mile of error handling: a typed error is what code reads, a sentence\n// is what a person reads, and every app was writing the funnel between the two.\n// The case everyone forgets is the request that never reached the server, which\n// without special handling renders as the nonsense \"erro 0\".\n\nimport { isApiError, syntheticDetail } from \"./errors\";\n\n/** The fixed sentences {@link describeApiError} may need. */\nexport interface ApiErrorStrings {\n    /** Shown when the request never reached the server. */\n    offline: string;\n    /**\n     * Shown when the backend rejected the payload field by field.\n     *\n     * The per-field messages are on `error.fields`, to be attached to the inputs\n     * themselves; this sentence is what the toast says.\n     *\n     * It does not apply to the one rejection that named a single field with a\n     * finished sentence — there the server's own `detail` is shown instead, since\n     * it is the same string `fields` carries. Pass `useDetail: false` to force\n     * this sentence in that case too.\n     */\n    validation: string;\n}\n\n/**\n * PT-BR defaults, used when no strings are supplied and no catalog answers.\n *\n * The SDK's copy is pt-BR everywhere else (`FilterBar`, `DataTable`, `Chat`), so\n * the default here matches rather than introducing an English string that only\n * shows up on a network failure.\n */\nexport const DEFAULT_API_ERROR_STRINGS: ApiErrorStrings = {\n    offline: \"Sem conexão com o servidor. Verifique sua internet e tente de novo.\",\n    validation: \"Confira os campos destacados e tente de novo.\",\n};\n\n/**\n * Translation key the {@link useDescribeApiError} hook looks up.\n *\n * A catalog that does not define it falls back to\n * {@link DEFAULT_API_ERROR_STRINGS}, because `t` returns the key itself when the\n * lookup misses and printing `tempest.error.offline` at the user would be worse\n * than printing pt-BR at them.\n */\nexport const API_ERROR_OFFLINE_KEY = \"tempest.error.offline\";\n\n/**\n * Translation key for the validation sentence, looked up the same way as\n * {@link API_ERROR_OFFLINE_KEY}.\n */\nexport const API_ERROR_VALIDATION_KEY = \"tempest.error.validation\";\n\n/**\n * Everything {@link describeApiError} accepts beyond the error and the fallback.\n *\n * Extends the fixed sentences rather than sitting beside them, so a caller that\n * already passed `{ offline, validation }` keeps compiling untouched.\n */\nexport interface DescribeApiErrorOptions extends Partial<ApiErrorStrings> {\n    /**\n     * Maps the backend's programmatic `code` to a sentence in your language.\n     *\n     * The client already surfaces `code` on `ApiError`, but without this every\n     * app writes the same `switch` over it. A hit here wins over every other\n     * step: it is the only sentence written for that exact case, by someone who\n     * knew both the backend contract and the screen it lands on.\n     */\n    codes?: Readonly<Record<string, string>>;\n    /**\n     * Maps an HTTP status to a sentence, for the failures that arrive with no\n     * useful body.\n     *\n     * `codes` covers the cases the backend named; this covers the ones it did\n     * not. The reference case is the `403` of an admin-only route: the body\n     * carries a generic `detail` (or none), so the funnel fell through to the\n     * fallback and an administrator read \"Não foi possível carregar\" when the\n     * fact that answers their question is \"esta listagem é só para\n     * administradores\".\n     *\n     * Checked after `codes` and **before** the backend's `detail`: a generic\n     * sentence emitted by the framework is worse than the one the app wrote for\n     * that status. `useDetail: false` remains the way to suppress `detail`\n     * entirely.\n     *\n     * A `0` key is honoured like any other, ahead of the offline sentence —\n     * `statuses` is the caller's explicit map, and the fixed `offline` string is\n     * already the way to reword that case. Status `0` covers a request that\n     * never landed **and** one abandoned by the client timeout, so an app that\n     * maps it is taking both.\n     */\n    statuses?: Readonly<Record<number, string>>;\n    /**\n     * Whether the backend's `detail` may be shown when no `code` matched.\n     * Default `true`.\n     *\n     * Set it to `false` when `detail` is written for developers rather than\n     * users, or when it could echo internals — the result is then always either\n     * a sentence you wrote or the fallback.\n     */\n    useDetail?: boolean;\n}\n\n/**\n * Whether the browser currently reports itself as offline.\n *\n * `fetch` rejects a network failure with a plain `TypeError` whose message\n * differs per browser (\"Failed to fetch\", \"NetworkError when attempting to fetch\n * resource.\", \"Load failed\"), so sniffing the message is not portable. The online\n * flag is, and it is the signal that matters for the sentence being chosen.\n *\n * @returns `true` only when the environment positively says it is offline.\n */\nfunction browserIsOffline(): boolean {\n    return typeof navigator !== \"undefined\" && navigator.onLine === false;\n}\n\n/**\n * Whether `fields` is the flattened single-field envelope, carrying `detail`.\n *\n * The check is identity rather than shape-sniffing. `collectFields` has exactly\n * two sources: FastAPI's `detail` **list**, whose entries are the per-issue\n * messages, and the flattened envelope, whose one entry is built from the same\n * string that becomes `ApiError.detail`. So one entry equal to `detail` can only\n * have come from the second, and returning `detail` there shows the string the\n * form is already about to attach to that input.\n *\n * @param fields - The error's field messages.\n * @param detail - `error.detail`, already trimmed.\n * @param status - The HTTP status, to recognise the synthetic `Erro <status>`\n *     that stands in when the body carried no message at all.\n * @returns Whether `detail` is safe to show as the sentence.\n */\nfunction singleFieldSentence(\n    fields: Record<string, string>,\n    detail: string,\n    status: number,\n): boolean {\n    if (detail === \"\" || detail === syntheticDetail(status)) return false;\n    const messages = Object.values(fields);\n    return messages.length === 1 && messages[0].trim() === detail;\n}\n\n/**\n * Turn any caught value into a sentence worth showing.\n *\n * The funnel, in order:\n *\n * 0. `codes[error.code]` — the sentence you wrote for that exact backend case.\n *    Checked first because nothing the funnel derives can beat it, and because a\n *    request that never landed carries no `code` for it to shadow.\n * 0.5. `statuses[error.status]` — the sentence for a whole class of failure,\n *    for the errors that arrive with no useful body. It beats the backend's\n *    `detail`, because a generic line emitted by the framework is worse than the\n *    one the app wrote for that status, and it beats the offline sentence when\n *    the caller maps `0` explicitly.\n * 1. A request that never reached the server — `status === 0`, or a non-API\n *    error thrown while the browser reports itself offline — produces the\n *    offline sentence. This is the step apps skip, and skipping it renders\n *    \"erro 0\" or a raw `TypeError` at the user.\n * 2. A validation rejection — `error.fields` is set — produces the validation\n *    sentence, **not** `detail`. On a FastAPI `422` the `detail` line is assembled\n *    from the backend's field paths and the validator's own wording\n *    (`\"items.0.price: Input should be greater than 0\"`), which is right for a\n *    log and wrong for a person: it is half English in a pt-BR screen and it\n *    names internals. The per-field messages stay on `fields`, where a form can\n *    attach them to the inputs that failed.\n *\n *    **Unless the rejection named exactly one field and its message is\n *    `detail` itself**, in which case `detail` is returned. That is not a guess\n *    about the text: `collectFields` fills a single entry from `detail` only for\n *    the flattened envelope a `tempest-fastapi-sdk` backend sends, where the\n *    server wrote one finished sentence about one field (`\"CPF ou CNPJ\n *    inválido\"`). Returning it shows the same string that is already on\n *    `fields`, so nothing is invented and nothing is lost. The assembled FastAPI\n *    line never reaches this branch, because it comes from the `detail` **list**\n *    and its entries are the per-issue messages, not `detail`.\n *\n *    This is a fix, not a preference. Before `namedField` shipped in 0.54.0,\n *    `fields` was empty against that backend and the sentence reached the user\n *    through step 3; filling `fields` silently replaced it with \"Confira os\n *    campos destacados\", which presumes a screen that highlights fields — and\n *    no app highlighted anything on the day of the bump.\n *\n *    `useDetail: false` still suppresses it, and is the way to force the fixed\n *    sentence for a backend whose text is written for developers. `validation`\n *    does **not** override it, and that is on purpose: its own contract is the\n *    sentence for a payload rejected *field by field*, which one field carrying\n *    one finished sentence is not — and `useDescribeApiError` always passes\n *    `validation`, so treating it as an override would mean the branch never ran\n *    for any component, which is every caller that matters here.\n * 3. The backend's own `detail`, which is the most specific thing available and\n *    is already written for a person — unless `useDetail: false` says that text\n *    is for developers.\n * 4. `fallback`, with `(HTTP <status>)` appended when a status is known, so the\n *    screenshot in the support ticket carries the one fact a developer needs.\n *\n * Pure on purpose: it works in an interceptor, in a logger and anywhere outside\n * the React tree. {@link useDescribeApiError} is the same funnel with the\n * sentences resolved through `I18nProvider`.\n *\n * @example\n * catch (error) {\n *     toast(describeApiError(error, \"Não foi possível salvar o pedido\"));\n * }\n *\n * @example\n * catch (error) {\n *     toast(\n *         describeApiError(error, \"Não foi possível se candidatar\", {\n *             codes: {\n *                 SERVICE_FULL: \"Este serviço atingiu o limite de vagas.\",\n *                 CANDIDATE_ALREADY_EXISTS: \"Você já se candidatou a este serviço.\",\n *             },\n *             useDetail: false,\n *         }),\n *     );\n * }\n *\n * @param error - The caught value, of any shape.\n * @param fallback - What to say when the error carries nothing better.\n * @param options - A `codes` catalog, `useDetail`, and overrides for the fixed\n *     sentences.\n * @returns A sentence to show the user.\n */\nexport function describeApiError(\n    error: unknown,\n    fallback: string,\n    options?: DescribeApiErrorOptions,\n): string {\n    const offline = options?.offline ?? DEFAULT_API_ERROR_STRINGS.offline;\n\n    if (isApiError(error)) {\n        const mapped = error.code === undefined ? undefined : options?.codes?.[error.code];\n        if (mapped !== undefined) return mapped;\n        const byStatus = options?.statuses?.[error.status];\n        if (byStatus !== undefined) return byStatus;\n        if (error.status === 0) return offline;\n        const detail = error.detail.trim();\n        if (error.fields && Object.keys(error.fields).length > 0) {\n            if (\n                options?.useDetail !== false &&\n                singleFieldSentence(error.fields, detail, error.status)\n            ) {\n                return detail;\n            }\n            return options?.validation ?? DEFAULT_API_ERROR_STRINGS.validation;\n        }\n        if (\n            options?.useDetail !== false &&\n            detail !== \"\" &&\n            detail !== syntheticDetail(error.status)\n        ) {\n            return detail;\n        }\n        return `${fallback} (HTTP ${error.status})`;\n    }\n\n    if (browserIsOffline()) return offline;\n\n    return fallback;\n}\n"],"mappings":";;AAgCA,IAAaA,IAA6C;CACtD,SAAS;CACT,YAAY;AAChB,GAUaC,IAAwB,yBAMxBC,IAA2B;AA8DxC,SAASC,IAA4B;CACjC,OAAO,OAAO,YAAc,OAAe,UAAU,WAAW;AACpE;AAkBA,SAASC,EACL,GACA,GACA,GACO;CACP,IAAIC,MAAW,MAAMA,MAAWC,EAAgBC,CAAM,GAAG,OAAO;CAChE,IAAMC,IAAW,OAAO,OAAOC,CAAM;CACrC,OAAOD,EAAS,WAAW,KAAKA,EAAS,EAAE,CAAC,KAAK,MAAMH;AAC3D;AAoFA,SAAgBK,EACZ,GACA,GACA,GACM;CACN,IAAMC,IAAUC,GAAS,WAAWZ,EAA0B;CAE9D,IAAIa,EAAWC,CAAK,GAAG;EACnB,IAAMC,IAASD,EAAM,SAAS,KAAA,IAAY,KAAA,IAAYF,GAAS,QAAQE,EAAM;EAC7E,IAAIC,MAAW,KAAA,GAAW,OAAOA;EACjC,IAAMC,IAAWJ,GAAS,WAAWE,EAAM;EAC3C,IAAIE,MAAa,KAAA,GAAW,OAAOA;EACnC,IAAIF,EAAM,WAAW,GAAG,OAAOH;EAC/B,IAAMN,IAASS,EAAM,OAAO,KAAK;EAiBjC,OAhBIA,EAAM,UAAU,OAAO,KAAKA,EAAM,MAAM,CAAC,CAAC,SAAS,IAE/CF,GAAS,cAAc,MACvBR,EAAoBU,EAAM,QAAQT,GAAQS,EAAM,MAAM,IAE/CT,IAEJO,GAAS,cAAcZ,EAA0B,aAGxDY,GAAS,cAAc,MACvBP,MAAW,MACXA,MAAWC,EAAgBQ,EAAM,MAAM,IAEhCT,IAEJ,GAAGY,EAAS,SAASH,EAAM,OAAO;CAC7C;CAIA,OAFIX,EAAiB,IAAUQ,IAExBM;AACX"}

package/dist/http/errors.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"errors.cjs","names":[],"sources":["../../src/http/errors.ts"],"sourcesContent":["import type { ApiError } from \"./types\";\n\n/**\n * Error thrown by {@link createApiClient} / {@link uploadWithProgress} on a\n * non-2xx response. Mirrors the Tempest FastAPI SDK error envelope\n * (`{ detail, code, details.request_id }`) so callers get a typed `code` and a\n * `requestId` for log correlation, while still being a real `Error` (stack\n * trace, `instanceof Error`).\n *\n * @example\n * try {\n *     await api.post(\"/users\", { body });\n * } catch (err) {\n *     if (isApiError(err) && err.code === \"EMAIL_TAKEN\") {\n *         showFieldError(\"email\", err.detail);\n *     }\n * }\n */\nexport class TempestApiError extends Error implements ApiError {\n    readonly status: number;\n    readonly detail: string;\n    readonly code?: string;\n    readonly requestId?: string;\n    readonly fields?: Record<string, string>;\n    readonly body?: unknown;\n\n    constructor(init: ApiError) {\n        super(init.detail);\n        this.name = \"TempestApiError\";\n        this.status = init.status;\n        this.detail = init.detail;\n        this.code = init.code;\n        this.requestId = init.requestId;\n        this.fields = init.fields;\n        this.body = init.body;\n    }\n}\n\n/**\n * Thrown when the session that started an operation is no longer the current\n * one by the time it settles: a `refresh` hook (rethrown by\n * {@link createApiClient}), or a `createTempestAuth` `login()` whose session\n * was replaced while it waited on the previous session's teardown.\n *\n * A refresh is a network round trip, and the session can end or change hands\n * during it: the user signs out, or signs out and another account signs in. The\n * tokens that refresh brings back belong to the session that ended, so they are\n * discarded instead of installed, and the request that was waiting on them is\n * not replayed — replaying it would send it as whoever is signed in now.\n *\n * This is deliberately not an unauthorized outcome. The client does **not** call\n * `onUnauthorized` for it: that callback ends the session, and the current\n * session — possibly a different account that just signed in — did nothing\n * wrong. Treat it like an aborted request: drop the result, show nothing.\n *\n * @example\n * try {\n *     await api.get(\"/api/orders\");\n * } catch (err) {\n *     if (err instanceof SessionSupersededError) return;\n *     throw err;\n * }\n */\nexport class SessionSupersededError extends Error {\n    constructor() {\n        super(\"A sessão mudou antes de a operação terminar.\");\n        this.name = \"SessionSupersededError\";\n    }\n}\n\n/**\n * Type guard for the {@link ApiError} shape. Matches both {@link TempestApiError}\n * instances and plain objects carrying `status` + `detail`.\n *\n * @param error - The unknown value (typically a caught error).\n * @returns Whether `error` conforms to the `ApiError` contract.\n */\nexport function isApiError(error: unknown): error is ApiError {\n    return (\n        typeof error === \"object\" &&\n        error !== null &&\n        typeof (error as ApiError).status === \"number\" &&\n        typeof (error as ApiError).detail === \"string\"\n    );\n}\n\n/**\n * Location prefixes FastAPI puts at the head of a validation error's `loc`,\n * naming the part of the request rather than the field. Dropped from the\n * rendered path, so `[\"body\", \"email\"]` reads as `email`.\n */\nconst LOC_ROOTS: ReadonlySet<string> = new Set([\"body\", \"query\", \"path\", \"header\", \"cookie\"]);\n\n/**\n * Render a FastAPI validation error's `loc` tuple as a dotted field path.\n *\n * @param loc - The raw `loc` value from one validation error entry.\n * @returns The dotted path (`\"items.0.price\"`), or undefined when `loc` carries\n *     nothing addressable.\n */\nfunction formatLoc(loc: unknown): string | undefined {\n    if (!Array.isArray(loc)) return undefined;\n    const parts = loc\n        .filter(\n            (part): part is string | number => typeof part === \"string\" || typeof part === \"number\",\n        )\n        .filter((part, index) => !(index === 0 && LOC_ROOTS.has(String(part))));\n    return parts.length > 0 ? parts.join(\".\") : undefined;\n}\n\n/**\n * How deep {@link normalizeDetail} follows a nested `detail` before giving up.\n *\n * A real envelope needs two or three levels: the list, an entry, the entry's\n * own `detail`. The cap exists because the body is untrusted input arriving on\n * the error path — a response nesting `{\"detail\":{\"detail\":…}}` twenty thousand\n * deep (a 220 KB body) overflowed the stack, and a `RangeError` thrown while\n * *building* the error is worse than the error: the caller's `catch` stops\n * receiving a `TempestApiError`, so `isApiError` is false, `describeApiError`\n * has nothing to read and the `401` handling never runs.\n */\nconst MAX_DETAIL_DEPTH = 4;\n\n/**\n * Pull field-level messages out of a validation `detail` **list**.\n *\n * FastAPI's `422` body is `detail: [{ loc, msg, type }]`, which is exactly what\n * a form needs and exactly what the flattened `detail` string destroys. Only the\n * top level is read: a validation error names one field per entry, and following\n * nesting here would invent paths the backend never sent.\n *\n * This is one of two ways a body names a field — see {@link collectFields}, which\n * is the entry point and falls back to the singular keys when the list names\n * nothing addressable.\n *\n * @param raw - The `detail` value from the error body.\n * @returns Field path to message, or undefined when the body is not a\n *     validation list (or carries no entry naming a field).\n */\nfunction collectListFields(raw: unknown): Record<string, string> | undefined {\n    if (!Array.isArray(raw)) return undefined;\n\n    const fields: Record<string, string> = {};\n    for (const entry of raw) {\n        if (typeof entry !== \"object\" || entry === null) continue;\n        const record = entry as Record<string, unknown>;\n        const field = formatLoc(record.loc);\n        if (field === undefined || field in fields) continue;\n        const message = normalizeDetail(record.msg) ?? normalizeDetail(record.message);\n        if (message === undefined) continue;\n        fields[field] = message;\n    }\n\n    return Object.keys(fields).length > 0 ? fields : undefined;\n}\n\n/**\n * Narrow a value to a plain object — a record, and not an array.\n *\n * Arrays are excluded because `typeof [] === \"object\"` while a list means\n * something else entirely here: FastAPI's `detail` list is read by\n * {@link collectListFields}, and reading `.field` off it would only ever be\n * undefined.\n *\n * @param value - The candidate value from the error body.\n * @returns The value as a record, or undefined when it is not a plain object.\n */\nfunction plainRecord(value: unknown): Record<string, unknown> | undefined {\n    return typeof value === \"object\" && value !== null && !Array.isArray(value)\n        ? (value as Record<string, unknown>)\n        : undefined;\n}\n\n/**\n * Read the field a **singular** error envelope names.\n *\n * A backend built on `tempest-fastapi-sdk` never answers with FastAPI's `detail`\n * list once it owns the handler: it names the guilty field in a key beside the\n * message. Three shapes are seen in the wild, and they are read inner-out:\n *\n * 1. `detail.field` — the field sits in the same object as the message it\n *    describes (`{ detail: { detail: \"Cidade não encontrada…\", field: \"city\" } }`),\n *    so it is the least ambiguous claim about which message belongs to which input.\n * 2. `field` at the top level — a flattened `RequestValidationError`\n *    (`{ detail: \"Value error, … for field 'phone' in 'body'\", field: \"phone\" }`)\n *    makes the same claim one level out.\n * 3. `details.field` — `details` is the envelope's free-form context bag, not a\n *    validation channel, and its `field` may be about something no input on screen\n *    carries (an unknown sort column, say). It answers last for exactly that reason.\n *\n * `location` (`\"body -> phone\"`) is deliberately not parsed: it renders the same\n * path `field` already names, no observed envelope sends it without `field`, and\n * splitting an arrow-separated string would invent a path the backend never sent.\n *\n * @param body - The parsed error body, or null when it was not an object.\n * @returns The field name, or undefined when none of the three keys carried a\n *     non-empty string — anything else is not usable as a key on `fields`.\n */\nfunction namedField(body: Record<string, unknown> | null): string | undefined {\n    if (body === null) return undefined;\n    const candidates: readonly unknown[] = [\n        plainRecord(body.detail)?.field,\n        body.field,\n        plainRecord(body.details)?.field,\n    ];\n    for (const candidate of candidates) {\n        if (typeof candidate === \"string\" && candidate !== \"\") return candidate;\n    }\n    return undefined;\n}\n\n/**\n * Drop the machine-readable tail a `tempest-fastapi-sdk` backend appends.\n *\n * That backend flattens a field error into\n * `\"CPF ou CNPJ inválido for field 'cpf_cnpj' in 'body'\"` — a finished sentence\n * in the app's language with an English clause glued to the end. The clause\n * carries nothing new: the same two values arrive as `field` and `location` on\n * the envelope, which is where `ApiError.fields` reads them from. Left in, it\n * reaches the user, and every consuming app grew its own regex to shave it off.\n *\n * The trim only fires when the field the tail names is the field the envelope\n * resolved to. That is what keeps it from deleting text it cannot account for:\n * a tail naming some other field is either a different envelope shape or a\n * sentence that genuinely reads that way, and both are left alone.\n *\n * @param message - The readable message, or undefined when the body had none.\n * @param field - The field name {@link namedField} resolved, if any.\n * @returns The message without the tail, or the message unchanged.\n */\nfunction trimFieldSuffix(\n    message: string | undefined,\n    field: string | undefined,\n): string | undefined {\n    if (message === undefined || field === undefined) return message;\n    const escaped = field.replace(/[.*+?^${}()|[\\]\\\\]/g, \"\\\\$&\");\n    const trimmed = message\n        .replace(new RegExp(`\\\\s+for field '${escaped}'(?:\\\\s+in\\\\s+'[^']*')?\\\\.?\\\\s*$`), \"\")\n        .trim();\n    return trimmed === \"\" ? message : trimmed;\n}\n\n/**\n * Index the body's field-level messages, whichever envelope carried them.\n *\n * The single entry point behind `ApiError.fields`, and it applies two rules the\n * tests pin:\n *\n * - FastAPI's `detail` list wins whenever it names at least one addressable\n *   field. A plain FastAPI app still answers a schema-level `422` with that list\n *   even on a `tempest-fastapi-sdk` backend, so it stays authoritative.\n * - A named field with no readable message produces nothing. The only string\n *   left at that point is the synthetic `Erro <status>`, and `{ phone: \"Erro 422\" }`\n *   on an input is noise rather than an error message.\n *\n * @param body - The parsed error body, or null when it was not an object.\n * @param message - The readable message the same body produced, before the\n *     synthetic fallback — the string that also becomes `ApiError.detail`.\n * @returns Field name to message, or undefined when nothing named a field.\n */\nfunction collectFields(\n    body: Record<string, unknown> | null,\n    message: string | undefined,\n): Record<string, string> | undefined {\n    const listed = collectListFields(body?.detail);\n    if (listed !== undefined) return listed;\n    const field = namedField(body);\n    if (field === undefined || message === undefined) return undefined;\n    return { [field]: message };\n}\n\n/**\n * Collapse a backend `detail` of any shape into a single readable line.\n *\n * FastAPI answers a `422` with `detail` as a **list** of\n * `{ loc, msg, type }` entries, not a string. Passing that through `String()`\n * yields `\"[object Object]\"` — an error message that tells the user nothing and\n * hides which field failed. Each entry becomes `\"<field>: <msg>\"` and the\n * entries are joined with `\"; \"`; a nested object is read through its\n * `msg`/`message`/`detail` string.\n *\n * @param raw - The `detail` (or `message`) value from the error body.\n * @param depth - Current nesting level. Past {@link MAX_DETAIL_DEPTH} the value\n *     is treated as unreadable instead of followed further.\n * @returns The rendered message, or undefined when nothing readable is there —\n *     letting the caller fall back to the synthetic `Erro <status>`.\n */\nfunction normalizeDetail(raw: unknown, depth: number = 0): string | undefined {\n    if (raw === null || raw === undefined) return undefined;\n    if (typeof raw === \"string\") return raw === \"\" ? undefined : raw;\n    if (typeof raw === \"number\" || typeof raw === \"boolean\") return String(raw);\n    if (depth >= MAX_DETAIL_DEPTH) return undefined;\n\n    if (Array.isArray(raw)) {\n        const lines = raw\n            .map((entry) => {\n                const message = normalizeDetail(entry, depth + 1);\n                if (message === undefined) return undefined;\n                const field =\n                    typeof entry === \"object\" && entry !== null\n                        ? formatLoc((entry as Record<string, unknown>).loc)\n                        : undefined;\n                return field === undefined ? message : `${field}: ${message}`;\n            })\n            .filter((line): line is string => line !== undefined);\n        return lines.length > 0 ? lines.join(\"; \") : undefined;\n    }\n\n    if (typeof raw === \"object\") {\n        const entry = raw as Record<string, unknown>;\n        return (\n            normalizeDetail(entry.msg, depth + 1) ??\n            normalizeDetail(entry.message, depth + 1) ??\n            normalizeDetail(entry.detail, depth + 1)\n        );\n    }\n\n    return undefined;\n}\n\n/**\n * Statuses worth a second attempt, as a set for the sub-500 cases.\n *\n * A network failure (status `0`), a request timeout, a too-early replay, and a\n * rate limit — which usually carries the `Retry-After` the backoff honours.\n * Everything else below 500 is the server refusing on purpose.\n */\nconst RETRIABLE_STATUSES: ReadonlySet<number> = new Set([0, 408, 425, 429]);\n\n/**\n * Whether an HTTP status describes a condition a replay can plausibly fix.\n *\n * The single owner of that decision. It used to be spelled out in three places —\n * the client's own policy, the react-query default and the bare `retry()` helper\n * — and they had already drifted: the query default was missing `425`, so the\n * same `425 Too Early` was replayed through `createApiClient({ retry: true })`\n * and not replayed through `useQuery`. Same app, same error, two behaviours, and\n * no test caught it because each file asserted against its own copy.\n *\n * Deliberately about the status and nothing else. Whether a *non*-API error is\n * worth replaying, and whether the request's method may be replayed at all, are\n * the caller's calls: {@link createApiClient} refuses a non-idempotent method,\n * while a bare `retry()` has no method to inspect.\n *\n * @example\n * await api.get(\"/report\", {\n *     retry: { shouldRetry: (error) => isApiError(error) && isRetriableStatus(error.status) },\n * });\n *\n * @param status - The HTTP status, where `0` means the request never landed.\n * @returns Whether a retry is worth attempting.\n */\nexport function isRetriableStatus(status: number): boolean {\n    return RETRIABLE_STATUSES.has(status) || status >= 500;\n}\n\n/**\n * Detail text synthesised when a response body carries none.\n *\n * Exported because {@link describeApiError} has to recognise it: a detail the\n * server never sent says strictly less than the caller's own fallback, so the\n * funnel drops it. Comparing against a copied literal would silently stop\n * matching the day this sentence is reworded — no type error, no failing test.\n *\n * @param status - The HTTP status of the error.\n * @returns The synthetic detail for that status.\n */\nexport function syntheticDetail(status: number): string {\n    return `Erro ${status}`;\n}\n\n/**\n * Parse an error body + response into the Tempest {@link ApiError} envelope.\n *\n * Reads `detail`/`message`, the programmatic `code`, and the correlation id\n * from `details.request_id` (falling back to the `X-Request-ID` header, then\n * the id the client sent).\n *\n * A `422` from FastAPI carries `detail` as a list of `{ loc, msg, type }`\n * entries, so it is flattened to `\"<field>: <msg>; <field>: <msg>\"` instead of\n * being stringified into `\"[object Object]\"`, and the same entries are indexed\n * on `fields` (`{ email: \"Field required\" }`) for a form to consume without\n * parsing that line back apart. The untouched body stays on `body`.\n *\n * A backend that owns its handlers — every `tempest-fastapi-sdk` app — sends no\n * such list, and names the field in a key instead:\n *\n * ```json\n * { \"detail\": \"Value error, … for field 'phone' in 'body'\", \"field\": \"phone\" }\n * { \"detail\": { \"detail\": \"Cidade não encontrada…\", \"field\": \"city\" },\n *   \"code\": \"VALIDATION_ERROR\", \"details\": { \"field\": \"city\" } }\n * ```\n *\n * Those are indexed too, keyed by the field the backend named and valued with the\n * same sentence that becomes `detail`. Precedence is the list first, then\n * `detail.field`, `field`, `details.field` — see {@link collectFields}.\n *\n * A flattened `detail` from the list is developer-facing: it carries the\n * backend's field paths and the validator's own wording. `describeApiError` knows\n * not to show it to a person when `fields` is set — which now also covers a\n * business error that named a field, whose `detail` was a finished sentence. That\n * sentence is not lost: it is on `fields`, attached to the input that failed.\n *\n * @param status - HTTP status code.\n * @param body - The parsed error body (object, string, or null).\n * @param headers - The response headers (for the `X-Request-ID` fallback).\n * @param sentRequestId - The id the client sent on the request, if any.\n * @returns A fully-populated `ApiError`.\n *\n * @tempest-limits param-count — the arguments are the response as it arrives\n * (`status`, `body`, `headers`) plus the id the request was sent with, and they are\n * passed at exactly three places, all of them a client's response path\n * (`createApiClient`, `uploadWithProgress`, `createResumableUpload`). Wrapping them\n * in an options object would name each argument twice at every call site to say\n * nothing new.\n */\nexport function buildApiError(\n    status: number,\n    body: unknown,\n    headers?: Headers | { get(name: string): string | null },\n    sentRequestId?: string,\n): ApiError {\n    const obj =\n        typeof body === \"object\" && body !== null ? (body as Record<string, unknown>) : null;\n    const message = trimFieldSuffix(\n        normalizeDetail(obj?.detail) ?? normalizeDetail(obj?.message),\n        namedField(obj),\n    );\n    const detail = message ?? syntheticDetail(status);\n    const code = typeof obj?.code === \"string\" ? obj.code : undefined;\n    const details =\n        typeof obj?.details === \"object\" && obj.details !== null\n            ? (obj.details as Record<string, unknown>)\n            : null;\n    const requestId =\n        (typeof details?.request_id === \"string\" ? details.request_id : undefined) ??\n        headers?.get(\"X-Request-ID\") ??\n        sentRequestId ??\n        undefined;\n\n    return {\n        status,\n        detail,\n        code,\n        requestId: requestId ?? undefined,\n        retryAfter: parseRetryAfter(headers?.get(\"Retry-After\")),\n        fields: collectFields(obj, message),\n        body,\n    };\n}\n\n/**\n * Parse a `Retry-After` header into seconds. Accepts a delta-seconds integer\n * (`\"120\"`) or an HTTP-date (`\"Wed, 21 Oct 2015 07:28:00 GMT\"`).\n *\n * @param value - The raw header value, or null.\n * @returns The delay in seconds (>= 0), or undefined when absent/unparseable.\n */\nexport function parseRetryAfter(value: string | null | undefined): number | undefined {\n    if (!value) return undefined;\n    const trimmed = value.trim();\n    if (/^\\d+$/.test(trimmed)) return Number(trimmed);\n    const when = Date.parse(trimmed);\n    if (Number.isNaN(when)) return undefined;\n    return Math.max(0, Math.round((when - Date.now()) / 1000));\n}\n"],"mappings":"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"}
+{"version":3,"file":"errors.cjs","names":["TempestApiError","init","SessionSupersededError","isApiError","error","LOC_ROOTS","formatLoc","loc","parts","part","index","MAX_DETAIL_DEPTH","collectListFields","raw","fields","entry","record","field","message","normalizeDetail","plainRecord","value","namedField","body","candidates","candidate","trimFieldSuffix","escaped","trimmed","collectFields","listed","lines","depth","line","RETRIABLE_STATUSES","isRetriableStatus","status","syntheticDetail","buildApiError","obj","detail","code","details","headers","sentRequestId","parseRetryAfter","when"],"sources":["../../src/http/errors.ts"],"sourcesContent":["import type { ApiError } from \"./types\";\n\n/**\n * Error thrown by {@link createApiClient} / {@link uploadWithProgress} on a\n * non-2xx response. Mirrors the Tempest FastAPI SDK error envelope\n * (`{ detail, code, details.request_id }`) so callers get a typed `code` and a\n * `requestId` for log correlation, while still being a real `Error` (stack\n * trace, `instanceof Error`).\n *\n * @example\n * try {\n *     await api.post(\"/users\", { body });\n * } catch (err) {\n *     if (isApiError(err) && err.code === \"EMAIL_TAKEN\") {\n *         showFieldError(\"email\", err.detail);\n *     }\n * }\n */\nexport class TempestApiError extends Error implements ApiError {\n    readonly status: number;\n    readonly detail: string;\n    readonly code?: string;\n    readonly requestId?: string;\n    readonly fields?: Record<string, string>;\n    readonly body?: unknown;\n\n    constructor(init: ApiError) {\n        super(init.detail);\n        this.name = \"TempestApiError\";\n        this.status = init.status;\n        this.detail = init.detail;\n        this.code = init.code;\n        this.requestId = init.requestId;\n        this.fields = init.fields;\n        this.body = init.body;\n    }\n}\n\n/**\n * Thrown when the session that started an operation is no longer the current\n * one by the time it settles: a `refresh` hook (rethrown by\n * {@link createApiClient}), or a `createTempestAuth` `login()` whose session\n * was replaced while it waited on the previous session's teardown.\n *\n * A refresh is a network round trip, and the session can end or change hands\n * during it: the user signs out, or signs out and another account signs in. The\n * tokens that refresh brings back belong to the session that ended, so they are\n * discarded instead of installed, and the request that was waiting on them is\n * not replayed — replaying it would send it as whoever is signed in now.\n *\n * This is deliberately not an unauthorized outcome. The client does **not** call\n * `onUnauthorized` for it: that callback ends the session, and the current\n * session — possibly a different account that just signed in — did nothing\n * wrong. Treat it like an aborted request: drop the result, show nothing.\n *\n * @example\n * try {\n *     await api.get(\"/api/orders\");\n * } catch (err) {\n *     if (err instanceof SessionSupersededError) return;\n *     throw err;\n * }\n */\nexport class SessionSupersededError extends Error {\n    constructor() {\n        super(\"A sessão mudou antes de a operação terminar.\");\n        this.name = \"SessionSupersededError\";\n    }\n}\n\n/**\n * Type guard for the {@link ApiError} shape. Matches both {@link TempestApiError}\n * instances and plain objects carrying `status` + `detail`.\n *\n * @param error - The unknown value (typically a caught error).\n * @returns Whether `error` conforms to the `ApiError` contract.\n */\nexport function isApiError(error: unknown): error is ApiError {\n    return (\n        typeof error === \"object\" &&\n        error !== null &&\n        typeof (error as ApiError).status === \"number\" &&\n        typeof (error as ApiError).detail === \"string\"\n    );\n}\n\n/**\n * Location prefixes FastAPI puts at the head of a validation error's `loc`,\n * naming the part of the request rather than the field. Dropped from the\n * rendered path, so `[\"body\", \"email\"]` reads as `email`.\n */\nconst LOC_ROOTS: ReadonlySet<string> = new Set([\"body\", \"query\", \"path\", \"header\", \"cookie\"]);\n\n/**\n * Render a FastAPI validation error's `loc` tuple as a dotted field path.\n *\n * @param loc - The raw `loc` value from one validation error entry.\n * @returns The dotted path (`\"items.0.price\"`), or undefined when `loc` carries\n *     nothing addressable.\n */\nfunction formatLoc(loc: unknown): string | undefined {\n    if (!Array.isArray(loc)) return undefined;\n    const parts = loc\n        .filter(\n            (part): part is string | number => typeof part === \"string\" || typeof part === \"number\",\n        )\n        .filter((part, index) => !(index === 0 && LOC_ROOTS.has(String(part))));\n    return parts.length > 0 ? parts.join(\".\") : undefined;\n}\n\n/**\n * How deep {@link normalizeDetail} follows a nested `detail` before giving up.\n *\n * A real envelope needs two or three levels: the list, an entry, the entry's\n * own `detail`. The cap exists because the body is untrusted input arriving on\n * the error path — a response nesting `{\"detail\":{\"detail\":…}}` twenty thousand\n * deep (a 220 KB body) overflowed the stack, and a `RangeError` thrown while\n * *building* the error is worse than the error: the caller's `catch` stops\n * receiving a `TempestApiError`, so `isApiError` is false, `describeApiError`\n * has nothing to read and the `401` handling never runs.\n */\nconst MAX_DETAIL_DEPTH = 4;\n\n/**\n * Pull field-level messages out of a validation `detail` **list**.\n *\n * FastAPI's `422` body is `detail: [{ loc, msg, type }]`, which is exactly what\n * a form needs and exactly what the flattened `detail` string destroys. Only the\n * top level is read: a validation error names one field per entry, and following\n * nesting here would invent paths the backend never sent.\n *\n * This is one of two ways a body names a field — see {@link collectFields}, which\n * is the entry point and falls back to the singular keys when the list names\n * nothing addressable.\n *\n * @param raw - The `detail` value from the error body.\n * @returns Field path to message, or undefined when the body is not a\n *     validation list (or carries no entry naming a field).\n */\nfunction collectListFields(raw: unknown): Record<string, string> | undefined {\n    if (!Array.isArray(raw)) return undefined;\n\n    const fields: Record<string, string> = {};\n    for (const entry of raw) {\n        if (typeof entry !== \"object\" || entry === null) continue;\n        const record = entry as Record<string, unknown>;\n        const field = formatLoc(record.loc);\n        if (field === undefined || field in fields) continue;\n        const message = normalizeDetail(record.msg) ?? normalizeDetail(record.message);\n        if (message === undefined) continue;\n        fields[field] = message;\n    }\n\n    return Object.keys(fields).length > 0 ? fields : undefined;\n}\n\n/**\n * Narrow a value to a plain object — a record, and not an array.\n *\n * Arrays are excluded because `typeof [] === \"object\"` while a list means\n * something else entirely here: FastAPI's `detail` list is read by\n * {@link collectListFields}, and reading `.field` off it would only ever be\n * undefined.\n *\n * @param value - The candidate value from the error body.\n * @returns The value as a record, or undefined when it is not a plain object.\n */\nfunction plainRecord(value: unknown): Record<string, unknown> | undefined {\n    return typeof value === \"object\" && value !== null && !Array.isArray(value)\n        ? (value as Record<string, unknown>)\n        : undefined;\n}\n\n/**\n * Read the field a **singular** error envelope names.\n *\n * A backend built on `tempest-fastapi-sdk` never answers with FastAPI's `detail`\n * list once it owns the handler: it names the guilty field in a key beside the\n * message. Three shapes are seen in the wild, and they are read inner-out:\n *\n * 1. `detail.field` — the field sits in the same object as the message it\n *    describes (`{ detail: { detail: \"Cidade não encontrada…\", field: \"city\" } }`),\n *    so it is the least ambiguous claim about which message belongs to which input.\n * 2. `field` at the top level — a flattened `RequestValidationError`\n *    (`{ detail: \"Value error, … for field 'phone' in 'body'\", field: \"phone\" }`)\n *    makes the same claim one level out.\n * 3. `details.field` — `details` is the envelope's free-form context bag, not a\n *    validation channel, and its `field` may be about something no input on screen\n *    carries (an unknown sort column, say). It answers last for exactly that reason.\n *\n * `location` (`\"body -> phone\"`) is deliberately not parsed: it renders the same\n * path `field` already names, no observed envelope sends it without `field`, and\n * splitting an arrow-separated string would invent a path the backend never sent.\n *\n * @param body - The parsed error body, or null when it was not an object.\n * @returns The field name, or undefined when none of the three keys carried a\n *     non-empty string — anything else is not usable as a key on `fields`.\n */\nfunction namedField(body: Record<string, unknown> | null): string | undefined {\n    if (body === null) return undefined;\n    const candidates: readonly unknown[] = [\n        plainRecord(body.detail)?.field,\n        body.field,\n        plainRecord(body.details)?.field,\n    ];\n    for (const candidate of candidates) {\n        if (typeof candidate === \"string\" && candidate !== \"\") return candidate;\n    }\n    return undefined;\n}\n\n/**\n * Drop the machine-readable tail a `tempest-fastapi-sdk` backend appends.\n *\n * That backend flattens a field error into\n * `\"CPF ou CNPJ inválido for field 'cpf_cnpj' in 'body'\"` — a finished sentence\n * in the app's language with an English clause glued to the end. The clause\n * carries nothing new: the same two values arrive as `field` and `location` on\n * the envelope, which is where `ApiError.fields` reads them from. Left in, it\n * reaches the user, and every consuming app grew its own regex to shave it off.\n *\n * The trim only fires when the field the tail names is the field the envelope\n * resolved to. That is what keeps it from deleting text it cannot account for:\n * a tail naming some other field is either a different envelope shape or a\n * sentence that genuinely reads that way, and both are left alone.\n *\n * @param message - The readable message, or undefined when the body had none.\n * @param field - The field name {@link namedField} resolved, if any.\n * @returns The message without the tail, or the message unchanged.\n */\nfunction trimFieldSuffix(\n    message: string | undefined,\n    field: string | undefined,\n): string | undefined {\n    if (message === undefined || field === undefined) return message;\n    const escaped = field.replace(/[.*+?^${}()|[\\]\\\\]/g, \"\\\\$&\");\n    const trimmed = message\n        .replace(new RegExp(`\\\\s+for field '${escaped}'(?:\\\\s+in\\\\s+'[^']*')?\\\\.?\\\\s*$`), \"\")\n        .trim();\n    return trimmed === \"\" ? message : trimmed;\n}\n\n/**\n * Index the body's field-level messages, whichever envelope carried them.\n *\n * The single entry point behind `ApiError.fields`, and it applies two rules the\n * tests pin:\n *\n * - FastAPI's `detail` list wins whenever it names at least one addressable\n *   field. A plain FastAPI app still answers a schema-level `422` with that list\n *   even on a `tempest-fastapi-sdk` backend, so it stays authoritative.\n * - A named field with no readable message produces nothing. The only string\n *   left at that point is the synthetic `Erro <status>`, and `{ phone: \"Erro 422\" }`\n *   on an input is noise rather than an error message.\n *\n * @param body - The parsed error body, or null when it was not an object.\n * @param message - The readable message the same body produced, before the\n *     synthetic fallback — the string that also becomes `ApiError.detail`.\n * @returns Field name to message, or undefined when nothing named a field.\n */\nfunction collectFields(\n    body: Record<string, unknown> | null,\n    message: string | undefined,\n): Record<string, string> | undefined {\n    const listed = collectListFields(body?.detail);\n    if (listed !== undefined) return listed;\n    const field = namedField(body);\n    if (field === undefined || message === undefined) return undefined;\n    return { [field]: message };\n}\n\n/**\n * Collapse a backend `detail` of any shape into a single readable line.\n *\n * FastAPI answers a `422` with `detail` as a **list** of\n * `{ loc, msg, type }` entries, not a string. Passing that through `String()`\n * yields `\"[object Object]\"` — an error message that tells the user nothing and\n * hides which field failed. Each entry becomes `\"<field>: <msg>\"` and the\n * entries are joined with `\"; \"`; a nested object is read through its\n * `msg`/`message`/`detail` string.\n *\n * @param raw - The `detail` (or `message`) value from the error body.\n * @param depth - Current nesting level. Past {@link MAX_DETAIL_DEPTH} the value\n *     is treated as unreadable instead of followed further.\n * @returns The rendered message, or undefined when nothing readable is there —\n *     letting the caller fall back to the synthetic `Erro <status>`.\n */\nfunction normalizeDetail(raw: unknown, depth: number = 0): string | undefined {\n    if (raw === null || raw === undefined) return undefined;\n    if (typeof raw === \"string\") return raw === \"\" ? undefined : raw;\n    if (typeof raw === \"number\" || typeof raw === \"boolean\") return String(raw);\n    if (depth >= MAX_DETAIL_DEPTH) return undefined;\n\n    if (Array.isArray(raw)) {\n        const lines = raw\n            .map((entry) => {\n                const message = normalizeDetail(entry, depth + 1);\n                if (message === undefined) return undefined;\n                const field =\n                    typeof entry === \"object\" && entry !== null\n                        ? formatLoc((entry as Record<string, unknown>).loc)\n                        : undefined;\n                return field === undefined ? message : `${field}: ${message}`;\n            })\n            .filter((line): line is string => line !== undefined);\n        return lines.length > 0 ? lines.join(\"; \") : undefined;\n    }\n\n    if (typeof raw === \"object\") {\n        const entry = raw as Record<string, unknown>;\n        return (\n            normalizeDetail(entry.msg, depth + 1) ??\n            normalizeDetail(entry.message, depth + 1) ??\n            normalizeDetail(entry.detail, depth + 1)\n        );\n    }\n\n    return undefined;\n}\n\n/**\n * Statuses worth a second attempt, as a set for the sub-500 cases.\n *\n * A network failure (status `0`), a request timeout, a too-early replay, and a\n * rate limit — which usually carries the `Retry-After` the backoff honours.\n * Everything else below 500 is the server refusing on purpose.\n */\nconst RETRIABLE_STATUSES: ReadonlySet<number> = new Set([0, 408, 425, 429]);\n\n/**\n * Whether an HTTP status describes a condition a replay can plausibly fix.\n *\n * The single owner of that decision. It used to be spelled out in three places —\n * the client's own policy, the react-query default and the bare `retry()` helper\n * — and they had already drifted: the query default was missing `425`, so the\n * same `425 Too Early` was replayed through `createApiClient({ retry: true })`\n * and not replayed through `useQuery`. Same app, same error, two behaviours, and\n * no test caught it because each file asserted against its own copy.\n *\n * Deliberately about the status and nothing else. Whether a *non*-API error is\n * worth replaying, and whether the request's method may be replayed at all, are\n * the caller's calls: {@link createApiClient} refuses a non-idempotent method,\n * while a bare `retry()` has no method to inspect.\n *\n * @example\n * await api.get(\"/report\", {\n *     retry: { shouldRetry: (error) => isApiError(error) && isRetriableStatus(error.status) },\n * });\n *\n * @param status - The HTTP status, where `0` means the request never landed.\n * @returns Whether a retry is worth attempting.\n */\nexport function isRetriableStatus(status: number): boolean {\n    return RETRIABLE_STATUSES.has(status) || status >= 500;\n}\n\n/**\n * Detail text synthesised when a response body carries none.\n *\n * Exported because {@link describeApiError} has to recognise it: a detail the\n * server never sent says strictly less than the caller's own fallback, so the\n * funnel drops it. Comparing against a copied literal would silently stop\n * matching the day this sentence is reworded — no type error, no failing test.\n *\n * @param status - The HTTP status of the error.\n * @returns The synthetic detail for that status.\n */\nexport function syntheticDetail(status: number): string {\n    return `Erro ${status}`;\n}\n\n/**\n * Parse an error body + response into the Tempest {@link ApiError} envelope.\n *\n * Reads `detail`/`message`, the programmatic `code`, and the correlation id\n * from `details.request_id` (falling back to the `X-Request-ID` header, then\n * the id the client sent).\n *\n * A `422` from FastAPI carries `detail` as a list of `{ loc, msg, type }`\n * entries, so it is flattened to `\"<field>: <msg>; <field>: <msg>\"` instead of\n * being stringified into `\"[object Object]\"`, and the same entries are indexed\n * on `fields` (`{ email: \"Field required\" }`) for a form to consume without\n * parsing that line back apart. The untouched body stays on `body`.\n *\n * A backend that owns its handlers — every `tempest-fastapi-sdk` app — sends no\n * such list, and names the field in a key instead:\n *\n * ```json\n * { \"detail\": \"Value error, … for field 'phone' in 'body'\", \"field\": \"phone\" }\n * { \"detail\": { \"detail\": \"Cidade não encontrada…\", \"field\": \"city\" },\n *   \"code\": \"VALIDATION_ERROR\", \"details\": { \"field\": \"city\" } }\n * ```\n *\n * Those are indexed too, keyed by the field the backend named and valued with the\n * same sentence that becomes `detail`. Precedence is the list first, then\n * `detail.field`, `field`, `details.field` — see {@link collectFields}.\n *\n * A flattened `detail` from the list is developer-facing: it carries the\n * backend's field paths and the validator's own wording. `describeApiError` knows\n * not to show it to a person when `fields` is set — which now also covers a\n * business error that named a field, whose `detail` was a finished sentence. That\n * sentence is not lost: it is on `fields`, attached to the input that failed.\n *\n * @param status - HTTP status code.\n * @param body - The parsed error body (object, string, or null).\n * @param headers - The response headers (for the `X-Request-ID` fallback).\n * @param sentRequestId - The id the client sent on the request, if any.\n * @returns A fully-populated `ApiError`.\n *\n * @tempest-limits param-count — the arguments are the response as it arrives\n * (`status`, `body`, `headers`) plus the id the request was sent with, and they are\n * passed at exactly three places, all of them a client's response path\n * (`createApiClient`, `uploadWithProgress`, `createResumableUpload`). Wrapping them\n * in an options object would name each argument twice at every call site to say\n * nothing new.\n */\nexport function buildApiError(\n    status: number,\n    body: unknown,\n    headers?: Headers | { get(name: string): string | null },\n    sentRequestId?: string,\n): ApiError {\n    const obj =\n        typeof body === \"object\" && body !== null ? (body as Record<string, unknown>) : null;\n    const message = trimFieldSuffix(\n        normalizeDetail(obj?.detail) ?? normalizeDetail(obj?.message),\n        namedField(obj),\n    );\n    const detail = message ?? syntheticDetail(status);\n    const code = typeof obj?.code === \"string\" ? obj.code : undefined;\n    const details =\n        typeof obj?.details === \"object\" && obj.details !== null\n            ? (obj.details as Record<string, unknown>)\n            : null;\n    const requestId =\n        (typeof details?.request_id === \"string\" ? details.request_id : undefined) ??\n        headers?.get(\"X-Request-ID\") ??\n        sentRequestId ??\n        undefined;\n\n    return {\n        status,\n        detail,\n        code,\n        requestId: requestId ?? undefined,\n        retryAfter: parseRetryAfter(headers?.get(\"Retry-After\")),\n        fields: collectFields(obj, message),\n        body,\n    };\n}\n\n/**\n * Parse a `Retry-After` header into seconds. Accepts a delta-seconds integer\n * (`\"120\"`) or an HTTP-date (`\"Wed, 21 Oct 2015 07:28:00 GMT\"`).\n *\n * @param value - The raw header value, or null.\n * @returns The delay in seconds (>= 0), or undefined when absent/unparseable.\n */\nexport function parseRetryAfter(value: string | null | undefined): number | undefined {\n    if (!value) return undefined;\n    const trimmed = value.trim();\n    if (/^\\d+$/.test(trimmed)) return Number(trimmed);\n    const when = Date.parse(trimmed);\n    if (Number.isNaN(when)) return undefined;\n    return Math.max(0, Math.round((when - Date.now()) / 1000));\n}\n"],"mappings":"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"}

package/dist/http/errors.js.map

@@ -1 +1 @@
-{"version":3,"file":"errors.js","names":[],"sources":["../../src/http/errors.ts"],"sourcesContent":["import type { ApiError } from \"./types\";\n\n/**\n * Error thrown by {@link createApiClient} / {@link uploadWithProgress} on a\n * non-2xx response. Mirrors the Tempest FastAPI SDK error envelope\n * (`{ detail, code, details.request_id }`) so callers get a typed `code` and a\n * `requestId` for log correlation, while still being a real `Error` (stack\n * trace, `instanceof Error`).\n *\n * @example\n * try {\n *     await api.post(\"/users\", { body });\n * } catch (err) {\n *     if (isApiError(err) && err.code === \"EMAIL_TAKEN\") {\n *         showFieldError(\"email\", err.detail);\n *     }\n * }\n */\nexport class TempestApiError extends Error implements ApiError {\n    readonly status: number;\n    readonly detail: string;\n    readonly code?: string;\n    readonly requestId?: string;\n    readonly fields?: Record<string, string>;\n    readonly body?: unknown;\n\n    constructor(init: ApiError) {\n        super(init.detail);\n        this.name = \"TempestApiError\";\n        this.status = init.status;\n        this.detail = init.detail;\n        this.code = init.code;\n        this.requestId = init.requestId;\n        this.fields = init.fields;\n        this.body = init.body;\n    }\n}\n\n/**\n * Thrown when the session that started an operation is no longer the current\n * one by the time it settles: a `refresh` hook (rethrown by\n * {@link createApiClient}), or a `createTempestAuth` `login()` whose session\n * was replaced while it waited on the previous session's teardown.\n *\n * A refresh is a network round trip, and the session can end or change hands\n * during it: the user signs out, or signs out and another account signs in. The\n * tokens that refresh brings back belong to the session that ended, so they are\n * discarded instead of installed, and the request that was waiting on them is\n * not replayed — replaying it would send it as whoever is signed in now.\n *\n * This is deliberately not an unauthorized outcome. The client does **not** call\n * `onUnauthorized` for it: that callback ends the session, and the current\n * session — possibly a different account that just signed in — did nothing\n * wrong. Treat it like an aborted request: drop the result, show nothing.\n *\n * @example\n * try {\n *     await api.get(\"/api/orders\");\n * } catch (err) {\n *     if (err instanceof SessionSupersededError) return;\n *     throw err;\n * }\n */\nexport class SessionSupersededError extends Error {\n    constructor() {\n        super(\"A sessão mudou antes de a operação terminar.\");\n        this.name = \"SessionSupersededError\";\n    }\n}\n\n/**\n * Type guard for the {@link ApiError} shape. Matches both {@link TempestApiError}\n * instances and plain objects carrying `status` + `detail`.\n *\n * @param error - The unknown value (typically a caught error).\n * @returns Whether `error` conforms to the `ApiError` contract.\n */\nexport function isApiError(error: unknown): error is ApiError {\n    return (\n        typeof error === \"object\" &&\n        error !== null &&\n        typeof (error as ApiError).status === \"number\" &&\n        typeof (error as ApiError).detail === \"string\"\n    );\n}\n\n/**\n * Location prefixes FastAPI puts at the head of a validation error's `loc`,\n * naming the part of the request rather than the field. Dropped from the\n * rendered path, so `[\"body\", \"email\"]` reads as `email`.\n */\nconst LOC_ROOTS: ReadonlySet<string> = new Set([\"body\", \"query\", \"path\", \"header\", \"cookie\"]);\n\n/**\n * Render a FastAPI validation error's `loc` tuple as a dotted field path.\n *\n * @param loc - The raw `loc` value from one validation error entry.\n * @returns The dotted path (`\"items.0.price\"`), or undefined when `loc` carries\n *     nothing addressable.\n */\nfunction formatLoc(loc: unknown): string | undefined {\n    if (!Array.isArray(loc)) return undefined;\n    const parts = loc\n        .filter(\n            (part): part is string | number => typeof part === \"string\" || typeof part === \"number\",\n        )\n        .filter((part, index) => !(index === 0 && LOC_ROOTS.has(String(part))));\n    return parts.length > 0 ? parts.join(\".\") : undefined;\n}\n\n/**\n * How deep {@link normalizeDetail} follows a nested `detail` before giving up.\n *\n * A real envelope needs two or three levels: the list, an entry, the entry's\n * own `detail`. The cap exists because the body is untrusted input arriving on\n * the error path — a response nesting `{\"detail\":{\"detail\":…}}` twenty thousand\n * deep (a 220 KB body) overflowed the stack, and a `RangeError` thrown while\n * *building* the error is worse than the error: the caller's `catch` stops\n * receiving a `TempestApiError`, so `isApiError` is false, `describeApiError`\n * has nothing to read and the `401` handling never runs.\n */\nconst MAX_DETAIL_DEPTH = 4;\n\n/**\n * Pull field-level messages out of a validation `detail` **list**.\n *\n * FastAPI's `422` body is `detail: [{ loc, msg, type }]`, which is exactly what\n * a form needs and exactly what the flattened `detail` string destroys. Only the\n * top level is read: a validation error names one field per entry, and following\n * nesting here would invent paths the backend never sent.\n *\n * This is one of two ways a body names a field — see {@link collectFields}, which\n * is the entry point and falls back to the singular keys when the list names\n * nothing addressable.\n *\n * @param raw - The `detail` value from the error body.\n * @returns Field path to message, or undefined when the body is not a\n *     validation list (or carries no entry naming a field).\n */\nfunction collectListFields(raw: unknown): Record<string, string> | undefined {\n    if (!Array.isArray(raw)) return undefined;\n\n    const fields: Record<string, string> = {};\n    for (const entry of raw) {\n        if (typeof entry !== \"object\" || entry === null) continue;\n        const record = entry as Record<string, unknown>;\n        const field = formatLoc(record.loc);\n        if (field === undefined || field in fields) continue;\n        const message = normalizeDetail(record.msg) ?? normalizeDetail(record.message);\n        if (message === undefined) continue;\n        fields[field] = message;\n    }\n\n    return Object.keys(fields).length > 0 ? fields : undefined;\n}\n\n/**\n * Narrow a value to a plain object — a record, and not an array.\n *\n * Arrays are excluded because `typeof [] === \"object\"` while a list means\n * something else entirely here: FastAPI's `detail` list is read by\n * {@link collectListFields}, and reading `.field` off it would only ever be\n * undefined.\n *\n * @param value - The candidate value from the error body.\n * @returns The value as a record, or undefined when it is not a plain object.\n */\nfunction plainRecord(value: unknown): Record<string, unknown> | undefined {\n    return typeof value === \"object\" && value !== null && !Array.isArray(value)\n        ? (value as Record<string, unknown>)\n        : undefined;\n}\n\n/**\n * Read the field a **singular** error envelope names.\n *\n * A backend built on `tempest-fastapi-sdk` never answers with FastAPI's `detail`\n * list once it owns the handler: it names the guilty field in a key beside the\n * message. Three shapes are seen in the wild, and they are read inner-out:\n *\n * 1. `detail.field` — the field sits in the same object as the message it\n *    describes (`{ detail: { detail: \"Cidade não encontrada…\", field: \"city\" } }`),\n *    so it is the least ambiguous claim about which message belongs to which input.\n * 2. `field` at the top level — a flattened `RequestValidationError`\n *    (`{ detail: \"Value error, … for field 'phone' in 'body'\", field: \"phone\" }`)\n *    makes the same claim one level out.\n * 3. `details.field` — `details` is the envelope's free-form context bag, not a\n *    validation channel, and its `field` may be about something no input on screen\n *    carries (an unknown sort column, say). It answers last for exactly that reason.\n *\n * `location` (`\"body -> phone\"`) is deliberately not parsed: it renders the same\n * path `field` already names, no observed envelope sends it without `field`, and\n * splitting an arrow-separated string would invent a path the backend never sent.\n *\n * @param body - The parsed error body, or null when it was not an object.\n * @returns The field name, or undefined when none of the three keys carried a\n *     non-empty string — anything else is not usable as a key on `fields`.\n */\nfunction namedField(body: Record<string, unknown> | null): string | undefined {\n    if (body === null) return undefined;\n    const candidates: readonly unknown[] = [\n        plainRecord(body.detail)?.field,\n        body.field,\n        plainRecord(body.details)?.field,\n    ];\n    for (const candidate of candidates) {\n        if (typeof candidate === \"string\" && candidate !== \"\") return candidate;\n    }\n    return undefined;\n}\n\n/**\n * Drop the machine-readable tail a `tempest-fastapi-sdk` backend appends.\n *\n * That backend flattens a field error into\n * `\"CPF ou CNPJ inválido for field 'cpf_cnpj' in 'body'\"` — a finished sentence\n * in the app's language with an English clause glued to the end. The clause\n * carries nothing new: the same two values arrive as `field` and `location` on\n * the envelope, which is where `ApiError.fields` reads them from. Left in, it\n * reaches the user, and every consuming app grew its own regex to shave it off.\n *\n * The trim only fires when the field the tail names is the field the envelope\n * resolved to. That is what keeps it from deleting text it cannot account for:\n * a tail naming some other field is either a different envelope shape or a\n * sentence that genuinely reads that way, and both are left alone.\n *\n * @param message - The readable message, or undefined when the body had none.\n * @param field - The field name {@link namedField} resolved, if any.\n * @returns The message without the tail, or the message unchanged.\n */\nfunction trimFieldSuffix(\n    message: string | undefined,\n    field: string | undefined,\n): string | undefined {\n    if (message === undefined || field === undefined) return message;\n    const escaped = field.replace(/[.*+?^${}()|[\\]\\\\]/g, \"\\\\$&\");\n    const trimmed = message\n        .replace(new RegExp(`\\\\s+for field '${escaped}'(?:\\\\s+in\\\\s+'[^']*')?\\\\.?\\\\s*$`), \"\")\n        .trim();\n    return trimmed === \"\" ? message : trimmed;\n}\n\n/**\n * Index the body's field-level messages, whichever envelope carried them.\n *\n * The single entry point behind `ApiError.fields`, and it applies two rules the\n * tests pin:\n *\n * - FastAPI's `detail` list wins whenever it names at least one addressable\n *   field. A plain FastAPI app still answers a schema-level `422` with that list\n *   even on a `tempest-fastapi-sdk` backend, so it stays authoritative.\n * - A named field with no readable message produces nothing. The only string\n *   left at that point is the synthetic `Erro <status>`, and `{ phone: \"Erro 422\" }`\n *   on an input is noise rather than an error message.\n *\n * @param body - The parsed error body, or null when it was not an object.\n * @param message - The readable message the same body produced, before the\n *     synthetic fallback — the string that also becomes `ApiError.detail`.\n * @returns Field name to message, or undefined when nothing named a field.\n */\nfunction collectFields(\n    body: Record<string, unknown> | null,\n    message: string | undefined,\n): Record<string, string> | undefined {\n    const listed = collectListFields(body?.detail);\n    if (listed !== undefined) return listed;\n    const field = namedField(body);\n    if (field === undefined || message === undefined) return undefined;\n    return { [field]: message };\n}\n\n/**\n * Collapse a backend `detail` of any shape into a single readable line.\n *\n * FastAPI answers a `422` with `detail` as a **list** of\n * `{ loc, msg, type }` entries, not a string. Passing that through `String()`\n * yields `\"[object Object]\"` — an error message that tells the user nothing and\n * hides which field failed. Each entry becomes `\"<field>: <msg>\"` and the\n * entries are joined with `\"; \"`; a nested object is read through its\n * `msg`/`message`/`detail` string.\n *\n * @param raw - The `detail` (or `message`) value from the error body.\n * @param depth - Current nesting level. Past {@link MAX_DETAIL_DEPTH} the value\n *     is treated as unreadable instead of followed further.\n * @returns The rendered message, or undefined when nothing readable is there —\n *     letting the caller fall back to the synthetic `Erro <status>`.\n */\nfunction normalizeDetail(raw: unknown, depth: number = 0): string | undefined {\n    if (raw === null || raw === undefined) return undefined;\n    if (typeof raw === \"string\") return raw === \"\" ? undefined : raw;\n    if (typeof raw === \"number\" || typeof raw === \"boolean\") return String(raw);\n    if (depth >= MAX_DETAIL_DEPTH) return undefined;\n\n    if (Array.isArray(raw)) {\n        const lines = raw\n            .map((entry) => {\n                const message = normalizeDetail(entry, depth + 1);\n                if (message === undefined) return undefined;\n                const field =\n                    typeof entry === \"object\" && entry !== null\n                        ? formatLoc((entry as Record<string, unknown>).loc)\n                        : undefined;\n                return field === undefined ? message : `${field}: ${message}`;\n            })\n            .filter((line): line is string => line !== undefined);\n        return lines.length > 0 ? lines.join(\"; \") : undefined;\n    }\n\n    if (typeof raw === \"object\") {\n        const entry = raw as Record<string, unknown>;\n        return (\n            normalizeDetail(entry.msg, depth + 1) ??\n            normalizeDetail(entry.message, depth + 1) ??\n            normalizeDetail(entry.detail, depth + 1)\n        );\n    }\n\n    return undefined;\n}\n\n/**\n * Statuses worth a second attempt, as a set for the sub-500 cases.\n *\n * A network failure (status `0`), a request timeout, a too-early replay, and a\n * rate limit — which usually carries the `Retry-After` the backoff honours.\n * Everything else below 500 is the server refusing on purpose.\n */\nconst RETRIABLE_STATUSES: ReadonlySet<number> = new Set([0, 408, 425, 429]);\n\n/**\n * Whether an HTTP status describes a condition a replay can plausibly fix.\n *\n * The single owner of that decision. It used to be spelled out in three places —\n * the client's own policy, the react-query default and the bare `retry()` helper\n * — and they had already drifted: the query default was missing `425`, so the\n * same `425 Too Early` was replayed through `createApiClient({ retry: true })`\n * and not replayed through `useQuery`. Same app, same error, two behaviours, and\n * no test caught it because each file asserted against its own copy.\n *\n * Deliberately about the status and nothing else. Whether a *non*-API error is\n * worth replaying, and whether the request's method may be replayed at all, are\n * the caller's calls: {@link createApiClient} refuses a non-idempotent method,\n * while a bare `retry()` has no method to inspect.\n *\n * @example\n * await api.get(\"/report\", {\n *     retry: { shouldRetry: (error) => isApiError(error) && isRetriableStatus(error.status) },\n * });\n *\n * @param status - The HTTP status, where `0` means the request never landed.\n * @returns Whether a retry is worth attempting.\n */\nexport function isRetriableStatus(status: number): boolean {\n    return RETRIABLE_STATUSES.has(status) || status >= 500;\n}\n\n/**\n * Detail text synthesised when a response body carries none.\n *\n * Exported because {@link describeApiError} has to recognise it: a detail the\n * server never sent says strictly less than the caller's own fallback, so the\n * funnel drops it. Comparing against a copied literal would silently stop\n * matching the day this sentence is reworded — no type error, no failing test.\n *\n * @param status - The HTTP status of the error.\n * @returns The synthetic detail for that status.\n */\nexport function syntheticDetail(status: number): string {\n    return `Erro ${status}`;\n}\n\n/**\n * Parse an error body + response into the Tempest {@link ApiError} envelope.\n *\n * Reads `detail`/`message`, the programmatic `code`, and the correlation id\n * from `details.request_id` (falling back to the `X-Request-ID` header, then\n * the id the client sent).\n *\n * A `422` from FastAPI carries `detail` as a list of `{ loc, msg, type }`\n * entries, so it is flattened to `\"<field>: <msg>; <field>: <msg>\"` instead of\n * being stringified into `\"[object Object]\"`, and the same entries are indexed\n * on `fields` (`{ email: \"Field required\" }`) for a form to consume without\n * parsing that line back apart. The untouched body stays on `body`.\n *\n * A backend that owns its handlers — every `tempest-fastapi-sdk` app — sends no\n * such list, and names the field in a key instead:\n *\n * ```json\n * { \"detail\": \"Value error, … for field 'phone' in 'body'\", \"field\": \"phone\" }\n * { \"detail\": { \"detail\": \"Cidade não encontrada…\", \"field\": \"city\" },\n *   \"code\": \"VALIDATION_ERROR\", \"details\": { \"field\": \"city\" } }\n * ```\n *\n * Those are indexed too, keyed by the field the backend named and valued with the\n * same sentence that becomes `detail`. Precedence is the list first, then\n * `detail.field`, `field`, `details.field` — see {@link collectFields}.\n *\n * A flattened `detail` from the list is developer-facing: it carries the\n * backend's field paths and the validator's own wording. `describeApiError` knows\n * not to show it to a person when `fields` is set — which now also covers a\n * business error that named a field, whose `detail` was a finished sentence. That\n * sentence is not lost: it is on `fields`, attached to the input that failed.\n *\n * @param status - HTTP status code.\n * @param body - The parsed error body (object, string, or null).\n * @param headers - The response headers (for the `X-Request-ID` fallback).\n * @param sentRequestId - The id the client sent on the request, if any.\n * @returns A fully-populated `ApiError`.\n *\n * @tempest-limits param-count — the arguments are the response as it arrives\n * (`status`, `body`, `headers`) plus the id the request was sent with, and they are\n * passed at exactly three places, all of them a client's response path\n * (`createApiClient`, `uploadWithProgress`, `createResumableUpload`). Wrapping them\n * in an options object would name each argument twice at every call site to say\n * nothing new.\n */\nexport function buildApiError(\n    status: number,\n    body: unknown,\n    headers?: Headers | { get(name: string): string | null },\n    sentRequestId?: string,\n): ApiError {\n    const obj =\n        typeof body === \"object\" && body !== null ? (body as Record<string, unknown>) : null;\n    const message = trimFieldSuffix(\n        normalizeDetail(obj?.detail) ?? normalizeDetail(obj?.message),\n        namedField(obj),\n    );\n    const detail = message ?? syntheticDetail(status);\n    const code = typeof obj?.code === \"string\" ? obj.code : undefined;\n    const details =\n        typeof obj?.details === \"object\" && obj.details !== null\n            ? (obj.details as Record<string, unknown>)\n            : null;\n    const requestId =\n        (typeof details?.request_id === \"string\" ? details.request_id : undefined) ??\n        headers?.get(\"X-Request-ID\") ??\n        sentRequestId ??\n        undefined;\n\n    return {\n        status,\n        detail,\n        code,\n        requestId: requestId ?? undefined,\n        retryAfter: parseRetryAfter(headers?.get(\"Retry-After\")),\n        fields: collectFields(obj, message),\n        body,\n    };\n}\n\n/**\n * Parse a `Retry-After` header into seconds. Accepts a delta-seconds integer\n * (`\"120\"`) or an HTTP-date (`\"Wed, 21 Oct 2015 07:28:00 GMT\"`).\n *\n * @param value - The raw header value, or null.\n * @returns The delay in seconds (>= 0), or undefined when absent/unparseable.\n */\nexport function parseRetryAfter(value: string | null | undefined): number | undefined {\n    if (!value) return undefined;\n    const trimmed = value.trim();\n    if (/^\\d+$/.test(trimmed)) return Number(trimmed);\n    const when = Date.parse(trimmed);\n    if (Number.isNaN(when)) return undefined;\n    return Math.max(0, Math.round((when - Date.now()) / 1000));\n}\n"],"mappings":"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"}
+{"version":3,"file":"errors.js","names":["TempestApiError","init","SessionSupersededError","isApiError","error","LOC_ROOTS","formatLoc","loc","parts","part","index","MAX_DETAIL_DEPTH","collectListFields","raw","fields","entry","record","field","message","normalizeDetail","plainRecord","value","namedField","body","candidates","candidate","trimFieldSuffix","escaped","trimmed","collectFields","listed","lines","depth","line","RETRIABLE_STATUSES","isRetriableStatus","status","syntheticDetail","buildApiError","obj","detail","code","details","headers","sentRequestId","parseRetryAfter","when"],"sources":["../../src/http/errors.ts"],"sourcesContent":["import type { ApiError } from \"./types\";\n\n/**\n * Error thrown by {@link createApiClient} / {@link uploadWithProgress} on a\n * non-2xx response. Mirrors the Tempest FastAPI SDK error envelope\n * (`{ detail, code, details.request_id }`) so callers get a typed `code` and a\n * `requestId` for log correlation, while still being a real `Error` (stack\n * trace, `instanceof Error`).\n *\n * @example\n * try {\n *     await api.post(\"/users\", { body });\n * } catch (err) {\n *     if (isApiError(err) && err.code === \"EMAIL_TAKEN\") {\n *         showFieldError(\"email\", err.detail);\n *     }\n * }\n */\nexport class TempestApiError extends Error implements ApiError {\n    readonly status: number;\n    readonly detail: string;\n    readonly code?: string;\n    readonly requestId?: string;\n    readonly fields?: Record<string, string>;\n    readonly body?: unknown;\n\n    constructor(init: ApiError) {\n        super(init.detail);\n        this.name = \"TempestApiError\";\n        this.status = init.status;\n        this.detail = init.detail;\n        this.code = init.code;\n        this.requestId = init.requestId;\n        this.fields = init.fields;\n        this.body = init.body;\n    }\n}\n\n/**\n * Thrown when the session that started an operation is no longer the current\n * one by the time it settles: a `refresh` hook (rethrown by\n * {@link createApiClient}), or a `createTempestAuth` `login()` whose session\n * was replaced while it waited on the previous session's teardown.\n *\n * A refresh is a network round trip, and the session can end or change hands\n * during it: the user signs out, or signs out and another account signs in. The\n * tokens that refresh brings back belong to the session that ended, so they are\n * discarded instead of installed, and the request that was waiting on them is\n * not replayed — replaying it would send it as whoever is signed in now.\n *\n * This is deliberately not an unauthorized outcome. The client does **not** call\n * `onUnauthorized` for it: that callback ends the session, and the current\n * session — possibly a different account that just signed in — did nothing\n * wrong. Treat it like an aborted request: drop the result, show nothing.\n *\n * @example\n * try {\n *     await api.get(\"/api/orders\");\n * } catch (err) {\n *     if (err instanceof SessionSupersededError) return;\n *     throw err;\n * }\n */\nexport class SessionSupersededError extends Error {\n    constructor() {\n        super(\"A sessão mudou antes de a operação terminar.\");\n        this.name = \"SessionSupersededError\";\n    }\n}\n\n/**\n * Type guard for the {@link ApiError} shape. Matches both {@link TempestApiError}\n * instances and plain objects carrying `status` + `detail`.\n *\n * @param error - The unknown value (typically a caught error).\n * @returns Whether `error` conforms to the `ApiError` contract.\n */\nexport function isApiError(error: unknown): error is ApiError {\n    return (\n        typeof error === \"object\" &&\n        error !== null &&\n        typeof (error as ApiError).status === \"number\" &&\n        typeof (error as ApiError).detail === \"string\"\n    );\n}\n\n/**\n * Location prefixes FastAPI puts at the head of a validation error's `loc`,\n * naming the part of the request rather than the field. Dropped from the\n * rendered path, so `[\"body\", \"email\"]` reads as `email`.\n */\nconst LOC_ROOTS: ReadonlySet<string> = new Set([\"body\", \"query\", \"path\", \"header\", \"cookie\"]);\n\n/**\n * Render a FastAPI validation error's `loc` tuple as a dotted field path.\n *\n * @param loc - The raw `loc` value from one validation error entry.\n * @returns The dotted path (`\"items.0.price\"`), or undefined when `loc` carries\n *     nothing addressable.\n */\nfunction formatLoc(loc: unknown): string | undefined {\n    if (!Array.isArray(loc)) return undefined;\n    const parts = loc\n        .filter(\n            (part): part is string | number => typeof part === \"string\" || typeof part === \"number\",\n        )\n        .filter((part, index) => !(index === 0 && LOC_ROOTS.has(String(part))));\n    return parts.length > 0 ? parts.join(\".\") : undefined;\n}\n\n/**\n * How deep {@link normalizeDetail} follows a nested `detail` before giving up.\n *\n * A real envelope needs two or three levels: the list, an entry, the entry's\n * own `detail`. The cap exists because the body is untrusted input arriving on\n * the error path — a response nesting `{\"detail\":{\"detail\":…}}` twenty thousand\n * deep (a 220 KB body) overflowed the stack, and a `RangeError` thrown while\n * *building* the error is worse than the error: the caller's `catch` stops\n * receiving a `TempestApiError`, so `isApiError` is false, `describeApiError`\n * has nothing to read and the `401` handling never runs.\n */\nconst MAX_DETAIL_DEPTH = 4;\n\n/**\n * Pull field-level messages out of a validation `detail` **list**.\n *\n * FastAPI's `422` body is `detail: [{ loc, msg, type }]`, which is exactly what\n * a form needs and exactly what the flattened `detail` string destroys. Only the\n * top level is read: a validation error names one field per entry, and following\n * nesting here would invent paths the backend never sent.\n *\n * This is one of two ways a body names a field — see {@link collectFields}, which\n * is the entry point and falls back to the singular keys when the list names\n * nothing addressable.\n *\n * @param raw - The `detail` value from the error body.\n * @returns Field path to message, or undefined when the body is not a\n *     validation list (or carries no entry naming a field).\n */\nfunction collectListFields(raw: unknown): Record<string, string> | undefined {\n    if (!Array.isArray(raw)) return undefined;\n\n    const fields: Record<string, string> = {};\n    for (const entry of raw) {\n        if (typeof entry !== \"object\" || entry === null) continue;\n        const record = entry as Record<string, unknown>;\n        const field = formatLoc(record.loc);\n        if (field === undefined || field in fields) continue;\n        const message = normalizeDetail(record.msg) ?? normalizeDetail(record.message);\n        if (message === undefined) continue;\n        fields[field] = message;\n    }\n\n    return Object.keys(fields).length > 0 ? fields : undefined;\n}\n\n/**\n * Narrow a value to a plain object — a record, and not an array.\n *\n * Arrays are excluded because `typeof [] === \"object\"` while a list means\n * something else entirely here: FastAPI's `detail` list is read by\n * {@link collectListFields}, and reading `.field` off it would only ever be\n * undefined.\n *\n * @param value - The candidate value from the error body.\n * @returns The value as a record, or undefined when it is not a plain object.\n */\nfunction plainRecord(value: unknown): Record<string, unknown> | undefined {\n    return typeof value === \"object\" && value !== null && !Array.isArray(value)\n        ? (value as Record<string, unknown>)\n        : undefined;\n}\n\n/**\n * Read the field a **singular** error envelope names.\n *\n * A backend built on `tempest-fastapi-sdk` never answers with FastAPI's `detail`\n * list once it owns the handler: it names the guilty field in a key beside the\n * message. Three shapes are seen in the wild, and they are read inner-out:\n *\n * 1. `detail.field` — the field sits in the same object as the message it\n *    describes (`{ detail: { detail: \"Cidade não encontrada…\", field: \"city\" } }`),\n *    so it is the least ambiguous claim about which message belongs to which input.\n * 2. `field` at the top level — a flattened `RequestValidationError`\n *    (`{ detail: \"Value error, … for field 'phone' in 'body'\", field: \"phone\" }`)\n *    makes the same claim one level out.\n * 3. `details.field` — `details` is the envelope's free-form context bag, not a\n *    validation channel, and its `field` may be about something no input on screen\n *    carries (an unknown sort column, say). It answers last for exactly that reason.\n *\n * `location` (`\"body -> phone\"`) is deliberately not parsed: it renders the same\n * path `field` already names, no observed envelope sends it without `field`, and\n * splitting an arrow-separated string would invent a path the backend never sent.\n *\n * @param body - The parsed error body, or null when it was not an object.\n * @returns The field name, or undefined when none of the three keys carried a\n *     non-empty string — anything else is not usable as a key on `fields`.\n */\nfunction namedField(body: Record<string, unknown> | null): string | undefined {\n    if (body === null) return undefined;\n    const candidates: readonly unknown[] = [\n        plainRecord(body.detail)?.field,\n        body.field,\n        plainRecord(body.details)?.field,\n    ];\n    for (const candidate of candidates) {\n        if (typeof candidate === \"string\" && candidate !== \"\") return candidate;\n    }\n    return undefined;\n}\n\n/**\n * Drop the machine-readable tail a `tempest-fastapi-sdk` backend appends.\n *\n * That backend flattens a field error into\n * `\"CPF ou CNPJ inválido for field 'cpf_cnpj' in 'body'\"` — a finished sentence\n * in the app's language with an English clause glued to the end. The clause\n * carries nothing new: the same two values arrive as `field` and `location` on\n * the envelope, which is where `ApiError.fields` reads them from. Left in, it\n * reaches the user, and every consuming app grew its own regex to shave it off.\n *\n * The trim only fires when the field the tail names is the field the envelope\n * resolved to. That is what keeps it from deleting text it cannot account for:\n * a tail naming some other field is either a different envelope shape or a\n * sentence that genuinely reads that way, and both are left alone.\n *\n * @param message - The readable message, or undefined when the body had none.\n * @param field - The field name {@link namedField} resolved, if any.\n * @returns The message without the tail, or the message unchanged.\n */\nfunction trimFieldSuffix(\n    message: string | undefined,\n    field: string | undefined,\n): string | undefined {\n    if (message === undefined || field === undefined) return message;\n    const escaped = field.replace(/[.*+?^${}()|[\\]\\\\]/g, \"\\\\$&\");\n    const trimmed = message\n        .replace(new RegExp(`\\\\s+for field '${escaped}'(?:\\\\s+in\\\\s+'[^']*')?\\\\.?\\\\s*$`), \"\")\n        .trim();\n    return trimmed === \"\" ? message : trimmed;\n}\n\n/**\n * Index the body's field-level messages, whichever envelope carried them.\n *\n * The single entry point behind `ApiError.fields`, and it applies two rules the\n * tests pin:\n *\n * - FastAPI's `detail` list wins whenever it names at least one addressable\n *   field. A plain FastAPI app still answers a schema-level `422` with that list\n *   even on a `tempest-fastapi-sdk` backend, so it stays authoritative.\n * - A named field with no readable message produces nothing. The only string\n *   left at that point is the synthetic `Erro <status>`, and `{ phone: \"Erro 422\" }`\n *   on an input is noise rather than an error message.\n *\n * @param body - The parsed error body, or null when it was not an object.\n * @param message - The readable message the same body produced, before the\n *     synthetic fallback — the string that also becomes `ApiError.detail`.\n * @returns Field name to message, or undefined when nothing named a field.\n */\nfunction collectFields(\n    body: Record<string, unknown> | null,\n    message: string | undefined,\n): Record<string, string> | undefined {\n    const listed = collectListFields(body?.detail);\n    if (listed !== undefined) return listed;\n    const field = namedField(body);\n    if (field === undefined || message === undefined) return undefined;\n    return { [field]: message };\n}\n\n/**\n * Collapse a backend `detail` of any shape into a single readable line.\n *\n * FastAPI answers a `422` with `detail` as a **list** of\n * `{ loc, msg, type }` entries, not a string. Passing that through `String()`\n * yields `\"[object Object]\"` — an error message that tells the user nothing and\n * hides which field failed. Each entry becomes `\"<field>: <msg>\"` and the\n * entries are joined with `\"; \"`; a nested object is read through its\n * `msg`/`message`/`detail` string.\n *\n * @param raw - The `detail` (or `message`) value from the error body.\n * @param depth - Current nesting level. Past {@link MAX_DETAIL_DEPTH} the value\n *     is treated as unreadable instead of followed further.\n * @returns The rendered message, or undefined when nothing readable is there —\n *     letting the caller fall back to the synthetic `Erro <status>`.\n */\nfunction normalizeDetail(raw: unknown, depth: number = 0): string | undefined {\n    if (raw === null || raw === undefined) return undefined;\n    if (typeof raw === \"string\") return raw === \"\" ? undefined : raw;\n    if (typeof raw === \"number\" || typeof raw === \"boolean\") return String(raw);\n    if (depth >= MAX_DETAIL_DEPTH) return undefined;\n\n    if (Array.isArray(raw)) {\n        const lines = raw\n            .map((entry) => {\n                const message = normalizeDetail(entry, depth + 1);\n                if (message === undefined) return undefined;\n                const field =\n                    typeof entry === \"object\" && entry !== null\n                        ? formatLoc((entry as Record<string, unknown>).loc)\n                        : undefined;\n                return field === undefined ? message : `${field}: ${message}`;\n            })\n            .filter((line): line is string => line !== undefined);\n        return lines.length > 0 ? lines.join(\"; \") : undefined;\n    }\n\n    if (typeof raw === \"object\") {\n        const entry = raw as Record<string, unknown>;\n        return (\n            normalizeDetail(entry.msg, depth + 1) ??\n            normalizeDetail(entry.message, depth + 1) ??\n            normalizeDetail(entry.detail, depth + 1)\n        );\n    }\n\n    return undefined;\n}\n\n/**\n * Statuses worth a second attempt, as a set for the sub-500 cases.\n *\n * A network failure (status `0`), a request timeout, a too-early replay, and a\n * rate limit — which usually carries the `Retry-After` the backoff honours.\n * Everything else below 500 is the server refusing on purpose.\n */\nconst RETRIABLE_STATUSES: ReadonlySet<number> = new Set([0, 408, 425, 429]);\n\n/**\n * Whether an HTTP status describes a condition a replay can plausibly fix.\n *\n * The single owner of that decision. It used to be spelled out in three places —\n * the client's own policy, the react-query default and the bare `retry()` helper\n * — and they had already drifted: the query default was missing `425`, so the\n * same `425 Too Early` was replayed through `createApiClient({ retry: true })`\n * and not replayed through `useQuery`. Same app, same error, two behaviours, and\n * no test caught it because each file asserted against its own copy.\n *\n * Deliberately about the status and nothing else. Whether a *non*-API error is\n * worth replaying, and whether the request's method may be replayed at all, are\n * the caller's calls: {@link createApiClient} refuses a non-idempotent method,\n * while a bare `retry()` has no method to inspect.\n *\n * @example\n * await api.get(\"/report\", {\n *     retry: { shouldRetry: (error) => isApiError(error) && isRetriableStatus(error.status) },\n * });\n *\n * @param status - The HTTP status, where `0` means the request never landed.\n * @returns Whether a retry is worth attempting.\n */\nexport function isRetriableStatus(status: number): boolean {\n    return RETRIABLE_STATUSES.has(status) || status >= 500;\n}\n\n/**\n * Detail text synthesised when a response body carries none.\n *\n * Exported because {@link describeApiError} has to recognise it: a detail the\n * server never sent says strictly less than the caller's own fallback, so the\n * funnel drops it. Comparing against a copied literal would silently stop\n * matching the day this sentence is reworded — no type error, no failing test.\n *\n * @param status - The HTTP status of the error.\n * @returns The synthetic detail for that status.\n */\nexport function syntheticDetail(status: number): string {\n    return `Erro ${status}`;\n}\n\n/**\n * Parse an error body + response into the Tempest {@link ApiError} envelope.\n *\n * Reads `detail`/`message`, the programmatic `code`, and the correlation id\n * from `details.request_id` (falling back to the `X-Request-ID` header, then\n * the id the client sent).\n *\n * A `422` from FastAPI carries `detail` as a list of `{ loc, msg, type }`\n * entries, so it is flattened to `\"<field>: <msg>; <field>: <msg>\"` instead of\n * being stringified into `\"[object Object]\"`, and the same entries are indexed\n * on `fields` (`{ email: \"Field required\" }`) for a form to consume without\n * parsing that line back apart. The untouched body stays on `body`.\n *\n * A backend that owns its handlers — every `tempest-fastapi-sdk` app — sends no\n * such list, and names the field in a key instead:\n *\n * ```json\n * { \"detail\": \"Value error, … for field 'phone' in 'body'\", \"field\": \"phone\" }\n * { \"detail\": { \"detail\": \"Cidade não encontrada…\", \"field\": \"city\" },\n *   \"code\": \"VALIDATION_ERROR\", \"details\": { \"field\": \"city\" } }\n * ```\n *\n * Those are indexed too, keyed by the field the backend named and valued with the\n * same sentence that becomes `detail`. Precedence is the list first, then\n * `detail.field`, `field`, `details.field` — see {@link collectFields}.\n *\n * A flattened `detail` from the list is developer-facing: it carries the\n * backend's field paths and the validator's own wording. `describeApiError` knows\n * not to show it to a person when `fields` is set — which now also covers a\n * business error that named a field, whose `detail` was a finished sentence. That\n * sentence is not lost: it is on `fields`, attached to the input that failed.\n *\n * @param status - HTTP status code.\n * @param body - The parsed error body (object, string, or null).\n * @param headers - The response headers (for the `X-Request-ID` fallback).\n * @param sentRequestId - The id the client sent on the request, if any.\n * @returns A fully-populated `ApiError`.\n *\n * @tempest-limits param-count — the arguments are the response as it arrives\n * (`status`, `body`, `headers`) plus the id the request was sent with, and they are\n * passed at exactly three places, all of them a client's response path\n * (`createApiClient`, `uploadWithProgress`, `createResumableUpload`). Wrapping them\n * in an options object would name each argument twice at every call site to say\n * nothing new.\n */\nexport function buildApiError(\n    status: number,\n    body: unknown,\n    headers?: Headers | { get(name: string): string | null },\n    sentRequestId?: string,\n): ApiError {\n    const obj =\n        typeof body === \"object\" && body !== null ? (body as Record<string, unknown>) : null;\n    const message = trimFieldSuffix(\n        normalizeDetail(obj?.detail) ?? normalizeDetail(obj?.message),\n        namedField(obj),\n    );\n    const detail = message ?? syntheticDetail(status);\n    const code = typeof obj?.code === \"string\" ? obj.code : undefined;\n    const details =\n        typeof obj?.details === \"object\" && obj.details !== null\n            ? (obj.details as Record<string, unknown>)\n            : null;\n    const requestId =\n        (typeof details?.request_id === \"string\" ? details.request_id : undefined) ??\n        headers?.get(\"X-Request-ID\") ??\n        sentRequestId ??\n        undefined;\n\n    return {\n        status,\n        detail,\n        code,\n        requestId: requestId ?? undefined,\n        retryAfter: parseRetryAfter(headers?.get(\"Retry-After\")),\n        fields: collectFields(obj, message),\n        body,\n    };\n}\n\n/**\n * Parse a `Retry-After` header into seconds. Accepts a delta-seconds integer\n * (`\"120\"`) or an HTTP-date (`\"Wed, 21 Oct 2015 07:28:00 GMT\"`).\n *\n * @param value - The raw header value, or null.\n * @returns The delay in seconds (>= 0), or undefined when absent/unparseable.\n */\nexport function parseRetryAfter(value: string | null | undefined): number | undefined {\n    if (!value) return undefined;\n    const trimmed = value.trim();\n    if (/^\\d+$/.test(trimmed)) return Number(trimmed);\n    const when = Date.parse(trimmed);\n    if (Number.isNaN(when)) return undefined;\n    return Math.max(0, Math.round((when - Date.now()) / 1000));\n}\n"],"mappings":"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"}

package/dist/http/idempotency.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"idempotency.cjs","names":[],"sources":["../../src/http/idempotency.ts"],"sourcesContent":["/**\n * Generate an RFC4122 v4 idempotency key (UUID). Use as the value for an\n * `Idempotency-Key` header on POST/PATCH requests that must not run twice.\n */\nexport function generateIdempotencyKey(): string {\n    if (typeof crypto !== \"undefined\" && \"randomUUID\" in crypto) {\n        return crypto.randomUUID();\n    }\n    return \"xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx\".replace(/[xy]/g, (c) => {\n        const r = Math.random() * 16;\n        const value = c === \"x\" ? Math.floor(r) : (Math.floor(r) & 0x3) | 0x8;\n        return value.toString(16);\n    });\n}\n"],"mappings":"AAIA,SAAgB,GAAiC,CAI7C,OAHI,OAAO,OAAW,KAAe,eAAgB,OAC1C,OAAO,WAAW,EAEtB,uCAAuC,QAAQ,QAAU,GAAM,CAClE,IAAM,EAAI,KAAK,OAAO,EAAI,GAE1B,OADc,IAAM,IAAM,KAAK,MAAM,CAAC,EAAK,KAAK,MAAM,CAAC,EAAI,EAAO,EAAA,CACrD,SAAS,EAAE,CAC5B,CAAC,CACL"}
+{"version":3,"file":"idempotency.cjs","names":["generateIdempotencyKey","r","c"],"sources":["../../src/http/idempotency.ts"],"sourcesContent":["/**\n * Generate an RFC4122 v4 idempotency key (UUID). Use as the value for an\n * `Idempotency-Key` header on POST/PATCH requests that must not run twice.\n */\nexport function generateIdempotencyKey(): string {\n    if (typeof crypto !== \"undefined\" && \"randomUUID\" in crypto) {\n        return crypto.randomUUID();\n    }\n    return \"xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx\".replace(/[xy]/g, (c) => {\n        const r = Math.random() * 16;\n        const value = c === \"x\" ? Math.floor(r) : (Math.floor(r) & 0x3) | 0x8;\n        return value.toString(16);\n    });\n}\n"],"mappings":"AAIA,SAAgBA,GAAiC,CAI7C,OAHI,OAAO,OAAW,KAAe,eAAgB,OAC1C,OAAO,WAAW,EAEtB,uCAAuC,QAAQ,QAAU,GAAM,CAClE,IAAMC,EAAI,KAAK,OAAO,EAAI,GAE1B,OADcC,IAAM,IAAM,KAAK,MAAMD,CAAC,EAAK,KAAK,MAAMA,CAAC,EAAI,EAAO,EAAA,CACrD,SAAS,EAAE,CAC5B,CAAC,CACL,C"}

package/dist/http/idempotency.js.map

@@ -1 +1 @@
-{"version":3,"file":"idempotency.js","names":[],"sources":["../../src/http/idempotency.ts"],"sourcesContent":["/**\n * Generate an RFC4122 v4 idempotency key (UUID). Use as the value for an\n * `Idempotency-Key` header on POST/PATCH requests that must not run twice.\n */\nexport function generateIdempotencyKey(): string {\n    if (typeof crypto !== \"undefined\" && \"randomUUID\" in crypto) {\n        return crypto.randomUUID();\n    }\n    return \"xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx\".replace(/[xy]/g, (c) => {\n        const r = Math.random() * 16;\n        const value = c === \"x\" ? Math.floor(r) : (Math.floor(r) & 0x3) | 0x8;\n        return value.toString(16);\n    });\n}\n"],"mappings":";AAIA,SAAgB,IAAiC;CAI7C,OAHI,OAAO,SAAW,OAAe,gBAAgB,SAC1C,OAAO,WAAW,IAEtB,uCAAuC,QAAQ,UAAU,MAAM;EAClE,IAAM,IAAI,KAAK,OAAO,IAAI;EAE1B,QADc,MAAM,MAAM,KAAK,MAAM,CAAC,IAAK,KAAK,MAAM,CAAC,IAAI,IAAO,EAAA,CACrD,SAAS,EAAE;CAC5B,CAAC;AACL"}
+{"version":3,"file":"idempotency.js","names":["generateIdempotencyKey","r","c"],"sources":["../../src/http/idempotency.ts"],"sourcesContent":["/**\n * Generate an RFC4122 v4 idempotency key (UUID). Use as the value for an\n * `Idempotency-Key` header on POST/PATCH requests that must not run twice.\n */\nexport function generateIdempotencyKey(): string {\n    if (typeof crypto !== \"undefined\" && \"randomUUID\" in crypto) {\n        return crypto.randomUUID();\n    }\n    return \"xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx\".replace(/[xy]/g, (c) => {\n        const r = Math.random() * 16;\n        const value = c === \"x\" ? Math.floor(r) : (Math.floor(r) & 0x3) | 0x8;\n        return value.toString(16);\n    });\n}\n"],"mappings":";AAIA,SAAgBA,IAAiC;CAI7C,OAHI,OAAO,SAAW,OAAe,gBAAgB,SAC1C,OAAO,WAAW,IAEtB,uCAAuC,QAAQ,UAAU,MAAM;EAClE,IAAMC,IAAI,KAAK,OAAO,IAAI;EAE1B,QADcC,MAAM,MAAM,KAAK,MAAMD,CAAC,IAAK,KAAK,MAAMA,CAAC,IAAI,IAAO,EAAA,CACrD,SAAS,EAAE;CAC5B,CAAC;AACL"}

package/dist/http/parse-response.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"parse-response.cjs","names":[],"sources":["../../src/http/parse-response.ts"],"sourcesContent":["import type { z } from \"zod\";\n\nimport { isDevBuild } from \"../utils/dev-mode\";\n\n/**\n * Validate an unknown response payload against a zod schema.\n *\n * A development build throws a detailed error naming every divergent field path\n * and embedding the raw payload; every other build throws a generic sentence, so\n * server internals never reach a user's screen or an error tracker.\n *\n * Which one you get comes from `isDevBuild()`, the SDK's single answer to that\n * question, rather than from a check written here. This function used to ask\n * `typeof process !== \"undefined\" && process.env?.NODE_ENV === \"development\"`,\n * and a browser has no `process` identifier at all — so the guard short-circuited\n * and the detailed branch was dead in exactly the build it was written for, no\n * matter what the bundler substituted behind it.\n *\n * The rule `isDevBuild()` applies is `NODE_ENV !== \"production\"`, which is wider\n * than the old `\"development\" || \"test\"`: a staging build that never sets\n * `NODE_ENV=production` gets the drift report, raw payload included.\n *\n * @param schema - The zod schema to parse against.\n * @param raw - The raw response payload.\n * @param context - A label used in error messages, e.g. \"POST /auth/login\".\n * @returns The parsed, typed payload.\n * @throws Error When the payload does not match the schema: `[parseResponse]\n * Contract drift on <context>` with the field paths and the raw payload in a\n * development build, `Resposta inválida do servidor (<context>).` otherwise.\n */\nexport function parseResponse<TSchema extends z.ZodTypeAny>(\n    schema: TSchema,\n    raw: unknown,\n    context: string,\n): z.infer<TSchema> {\n    const result = schema.safeParse(raw);\n    if (result.success) {\n        return result.data;\n    }\n\n    if (isDevBuild()) {\n        const issues = result.error.issues\n            .map((i) => `  - ${i.path.join(\".\") || \"<root>\"}: ${i.message}`)\n            .join(\"\\n\");\n        throw new Error(\n            `[parseResponse] Contract drift on ${context}:\\n${issues}\\n\\nRaw payload: ${JSON.stringify(raw, null, 2)}`,\n        );\n    }\n    throw new Error(`Resposta inválida do servidor (${context}).`);\n}\n"],"mappings":"yCA8BA,SAAgB,EACZ,EACA,EACA,EACgB,CAChB,IAAM,EAAS,EAAO,UAAU,CAAG,EACnC,GAAI,EAAO,QACP,OAAO,EAAO,KAGlB,GAAI,EAAA,WAAW,EAAG,CACd,IAAM,EAAS,EAAO,MAAM,OACvB,IAAK,GAAM,OAAO,EAAE,KAAK,KAAK,GAAG,GAAK,SAAS,IAAI,EAAE,SAAS,CAAC,CAC/D,KAAK;CAAI,EACd,MAAU,MACN,qCAAqC,EAAQ,KAAK,EAAO,mBAAmB,KAAK,UAAU,EAAK,KAAM,CAAC,GAC3G,CACJ,CACA,MAAU,MAAM,kCAAkC,EAAQ,GAAG,CACjE"}
+{"version":3,"file":"parse-response.cjs","names":["isDevBuild","require_dev_mode","parseResponse","result","schema","raw","issues","i","context"],"sources":["../../src/http/parse-response.ts"],"sourcesContent":["import type { z } from \"zod\";\n\nimport { isDevBuild } from \"../utils/dev-mode\";\n\n/**\n * Validate an unknown response payload against a zod schema.\n *\n * A development build throws a detailed error naming every divergent field path\n * and embedding the raw payload; every other build throws a generic sentence, so\n * server internals never reach a user's screen or an error tracker.\n *\n * Which one you get comes from `isDevBuild()`, the SDK's single answer to that\n * question, rather than from a check written here. This function used to ask\n * `typeof process !== \"undefined\" && process.env?.NODE_ENV === \"development\"`,\n * and a browser has no `process` identifier at all — so the guard short-circuited\n * and the detailed branch was dead in exactly the build it was written for, no\n * matter what the bundler substituted behind it.\n *\n * The rule `isDevBuild()` applies is `NODE_ENV !== \"production\"`, which is wider\n * than the old `\"development\" || \"test\"`: a staging build that never sets\n * `NODE_ENV=production` gets the drift report, raw payload included.\n *\n * @param schema - The zod schema to parse against.\n * @param raw - The raw response payload.\n * @param context - A label used in error messages, e.g. \"POST /auth/login\".\n * @returns The parsed, typed payload.\n * @throws Error When the payload does not match the schema: `[parseResponse]\n * Contract drift on <context>` with the field paths and the raw payload in a\n * development build, `Resposta inválida do servidor (<context>).` otherwise.\n */\nexport function parseResponse<TSchema extends z.ZodTypeAny>(\n    schema: TSchema,\n    raw: unknown,\n    context: string,\n): z.infer<TSchema> {\n    const result = schema.safeParse(raw);\n    if (result.success) {\n        return result.data;\n    }\n\n    if (isDevBuild()) {\n        const issues = result.error.issues\n            .map((i) => `  - ${i.path.join(\".\") || \"<root>\"}: ${i.message}`)\n            .join(\"\\n\");\n        throw new Error(\n            `[parseResponse] Contract drift on ${context}:\\n${issues}\\n\\nRaw payload: ${JSON.stringify(raw, null, 2)}`,\n        );\n    }\n    throw new Error(`Resposta inválida do servidor (${context}).`);\n}\n"],"mappings":"A,yCA8BA,SAAgBE,EACZ,EACA,EACA,EACgB,CAChB,IAAMC,EAASC,EAAO,UAAUC,CAAG,EACnC,GAAIF,EAAO,QACP,OAAOA,EAAO,KAGlB,GAAIH,EAAAA,WAAW,EAAG,CACd,IAAMM,EAASH,EAAO,MAAM,OACvB,IAAK,GAAM,OAAOI,EAAE,KAAK,KAAK,GAAG,GAAK,SAAS,IAAIA,EAAE,SAAS,CAAC,CAC/D,KAAK;CAAI,EACd,MAAU,MACN,qCAAqCC,EAAQ,KAAKF,EAAO,mBAAmB,KAAK,UAAUD,EAAK,KAAM,CAAC,GAC3G,CACJ,CACA,MAAU,MAAM,kCAAkCG,EAAQ,GAAG,CACjE,C"}

package/dist/http/parse-response.js.map

@@ -1 +1 @@
-{"version":3,"file":"parse-response.js","names":[],"sources":["../../src/http/parse-response.ts"],"sourcesContent":["import type { z } from \"zod\";\n\nimport { isDevBuild } from \"../utils/dev-mode\";\n\n/**\n * Validate an unknown response payload against a zod schema.\n *\n * A development build throws a detailed error naming every divergent field path\n * and embedding the raw payload; every other build throws a generic sentence, so\n * server internals never reach a user's screen or an error tracker.\n *\n * Which one you get comes from `isDevBuild()`, the SDK's single answer to that\n * question, rather than from a check written here. This function used to ask\n * `typeof process !== \"undefined\" && process.env?.NODE_ENV === \"development\"`,\n * and a browser has no `process` identifier at all — so the guard short-circuited\n * and the detailed branch was dead in exactly the build it was written for, no\n * matter what the bundler substituted behind it.\n *\n * The rule `isDevBuild()` applies is `NODE_ENV !== \"production\"`, which is wider\n * than the old `\"development\" || \"test\"`: a staging build that never sets\n * `NODE_ENV=production` gets the drift report, raw payload included.\n *\n * @param schema - The zod schema to parse against.\n * @param raw - The raw response payload.\n * @param context - A label used in error messages, e.g. \"POST /auth/login\".\n * @returns The parsed, typed payload.\n * @throws Error When the payload does not match the schema: `[parseResponse]\n * Contract drift on <context>` with the field paths and the raw payload in a\n * development build, `Resposta inválida do servidor (<context>).` otherwise.\n */\nexport function parseResponse<TSchema extends z.ZodTypeAny>(\n    schema: TSchema,\n    raw: unknown,\n    context: string,\n): z.infer<TSchema> {\n    const result = schema.safeParse(raw);\n    if (result.success) {\n        return result.data;\n    }\n\n    if (isDevBuild()) {\n        const issues = result.error.issues\n            .map((i) => `  - ${i.path.join(\".\") || \"<root>\"}: ${i.message}`)\n            .join(\"\\n\");\n        throw new Error(\n            `[parseResponse] Contract drift on ${context}:\\n${issues}\\n\\nRaw payload: ${JSON.stringify(raw, null, 2)}`,\n        );\n    }\n    throw new Error(`Resposta inválida do servidor (${context}).`);\n}\n"],"mappings":";;AA8BA,SAAgB,EACZ,GACA,GACA,GACgB;CAChB,IAAM,IAAS,EAAO,UAAU,CAAG;CACnC,IAAI,EAAO,SACP,OAAO,EAAO;CAGlB,IAAI,EAAW,GAAG;EACd,IAAM,IAAS,EAAO,MAAM,OACvB,KAAK,MAAM,OAAO,EAAE,KAAK,KAAK,GAAG,KAAK,SAAS,IAAI,EAAE,SAAS,CAAC,CAC/D,KAAK,IAAI;EACd,MAAU,MACN,qCAAqC,EAAQ,KAAK,EAAO,mBAAmB,KAAK,UAAU,GAAK,MAAM,CAAC,GAC3G;CACJ;CACA,MAAU,MAAM,kCAAkC,EAAQ,GAAG;AACjE"}
+{"version":3,"file":"parse-response.js","names":["parseResponse","result","schema","raw","isDevBuild","issues","i","context"],"sources":["../../src/http/parse-response.ts"],"sourcesContent":["import type { z } from \"zod\";\n\nimport { isDevBuild } from \"../utils/dev-mode\";\n\n/**\n * Validate an unknown response payload against a zod schema.\n *\n * A development build throws a detailed error naming every divergent field path\n * and embedding the raw payload; every other build throws a generic sentence, so\n * server internals never reach a user's screen or an error tracker.\n *\n * Which one you get comes from `isDevBuild()`, the SDK's single answer to that\n * question, rather than from a check written here. This function used to ask\n * `typeof process !== \"undefined\" && process.env?.NODE_ENV === \"development\"`,\n * and a browser has no `process` identifier at all — so the guard short-circuited\n * and the detailed branch was dead in exactly the build it was written for, no\n * matter what the bundler substituted behind it.\n *\n * The rule `isDevBuild()` applies is `NODE_ENV !== \"production\"`, which is wider\n * than the old `\"development\" || \"test\"`: a staging build that never sets\n * `NODE_ENV=production` gets the drift report, raw payload included.\n *\n * @param schema - The zod schema to parse against.\n * @param raw - The raw response payload.\n * @param context - A label used in error messages, e.g. \"POST /auth/login\".\n * @returns The parsed, typed payload.\n * @throws Error When the payload does not match the schema: `[parseResponse]\n * Contract drift on <context>` with the field paths and the raw payload in a\n * development build, `Resposta inválida do servidor (<context>).` otherwise.\n */\nexport function parseResponse<TSchema extends z.ZodTypeAny>(\n    schema: TSchema,\n    raw: unknown,\n    context: string,\n): z.infer<TSchema> {\n    const result = schema.safeParse(raw);\n    if (result.success) {\n        return result.data;\n    }\n\n    if (isDevBuild()) {\n        const issues = result.error.issues\n            .map((i) => `  - ${i.path.join(\".\") || \"<root>\"}: ${i.message}`)\n            .join(\"\\n\");\n        throw new Error(\n            `[parseResponse] Contract drift on ${context}:\\n${issues}\\n\\nRaw payload: ${JSON.stringify(raw, null, 2)}`,\n        );\n    }\n    throw new Error(`Resposta inválida do servidor (${context}).`);\n}\n"],"mappings":";;AA8BA,SAAgBA,EACZ,GACA,GACA,GACgB;CAChB,IAAMC,IAASC,EAAO,UAAUC,CAAG;CACnC,IAAIF,EAAO,SACP,OAAOA,EAAO;CAGlB,IAAIG,EAAW,GAAG;EACd,IAAMC,IAASJ,EAAO,MAAM,OACvB,KAAK,MAAM,OAAOK,EAAE,KAAK,KAAK,GAAG,KAAK,SAAS,IAAIA,EAAE,SAAS,CAAC,CAC/D,KAAK,IAAI;EACd,MAAU,MACN,qCAAqCC,EAAQ,KAAKF,EAAO,mBAAmB,KAAK,UAAUF,GAAK,MAAM,CAAC,GAC3G;CACJ;CACA,MAAU,MAAM,kCAAkCI,EAAQ,GAAG;AACjE"}

package/dist/http/presigned-post.cjs

@@ -0,0 +1,2 @@
+const e=require("./errors.cjs"),t=require("./upload-with-progress.cjs");var n={EntityTooLarge:{status:413,code:`FILE_TOO_LARGE`,detail:`Arquivo maior que o permitido.`},EntityTooSmall:{status:400,code:`FILE_TOO_SMALL`,detail:`Arquivo menor que o permitido.`},AccessDenied:{status:403,code:`SIGNED_URL_INVALID`,detail:`O link de envio não aceita este arquivo.`}},r=/policy expired/i;function i(e,t){return RegExp(`<${t}>([^<]*)</${t}>`).exec(e)?.[1]}function a(t){if(!(t instanceof e.TempestApiError)||typeof t.body!=`string`)return t;let a=i(t.body,`Code`);if(!a)return t;let o=i(t.body,`Message`)??``,s=a===`AccessDenied`&&r.test(o)?{status:403,code:`SIGNED_URL_EXPIRED`,detail:`O link de envio expirou.`}:n[a]??{status:t.status,code:a,detail:o};return new e.TempestApiError({status:s.status,code:s.code,detail:s.detail||t.detail,requestId:i(t.body,`RequestId`)??t.requestId,body:t.body})}async function o(n,r,i={}){let{onProgress:o,signal:s,fileName:c}=i;if(r.size>n.max_bytes)throw new e.TempestApiError({status:413,code:`FILE_TOO_LARGE`,detail:`Arquivo de ${r.size} bytes excede o limite de ${n.max_bytes} bytes.`});let l=new FormData;for(let[e,t]of Object.entries(n.fields))l.append(e,t);c===void 0?l.append(`file`,r):l.append(`file`,r,c);try{await t.uploadWithProgress({url:n.url,body:l,method:`POST`,requestId:()=>``,withCredentials:!1,onProgress:o,signal:s,parser:()=>void 0})}catch(e){throw a(e)}}exports.uploadPresignedPost=o;
+//# sourceMappingURL=presigned-post.cjs.map

package/dist/http/presigned-post.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"presigned-post.cjs","names":["TempestApiError","uploadWithProgress","require_errors","require_upload_with_progress","S3_ERRORS","EXPIRED_POLICY","xmlText","tag","xml","normalizeError","error","s3Code","message","mapped","uploadPresignedPost","options","file","post","form","name","value","fileName"],"sources":["../../src/http/presigned-post.ts"],"sourcesContent":["import { TempestApiError } from \"./errors\";\nimport { uploadWithProgress } from \"./upload-with-progress\";\nimport type { UploadProgressEvent } from \"./upload-with-progress\";\n\n/**\n * A pre-signed `POST` form, as `tempest-fastapi-sdk` >= 0.331.0 hands it out\n * (`presigned_post_policy` / `SubjectObjectStorage.presign_post`).\n *\n * Snake case on purpose: this is the wire shape, so it parses straight from the\n * response of the app's own route.\n */\nexport interface PresignedPost {\n    /** Where the form is posted: the bucket on S3/MinIO, or the API itself on the local backend. */\n    url: string;\n    /** Form fields to send before the file, in this order — `key`, `policy`, signature and the rest. */\n    fields: Record<string, string>;\n    /** Largest file the policy accepts, in bytes. */\n    max_bytes: number;\n}\n\nexport interface UploadPresignedPostOptions {\n    /** Called on every `progress` event of the upload. */\n    onProgress?: (event: UploadProgressEvent) => void;\n    /** Abort the upload; rejects with an `AbortError` `DOMException`. */\n    signal?: AbortSignal;\n    /** File name sent with the `file` part. Defaults to `file.name` for a `File`. */\n    fileName?: string;\n}\n\n/**\n * S3 error codes mapped to the codes the local storage backend of\n * `tempest-fastapi-sdk` answers with, so one `code` reaches the UI whichever\n * backend the service is configured with.\n *\n * Statuses follow the local backend too: S3 answers `EntityTooLarge` with `400`,\n * the local backend `FILE_TOO_LARGE` with `413`. Measured against MinIO\n * `RELEASE.2025-04-22T22-12-26Z` from Chrome, cross-origin: the XML error body is\n * readable (MinIO sends CORS headers on errors), an expired policy and a broken\n * condition are both `AccessDenied` and differ only in the message\n * (`Policy expired` / `Policy Condition failed`).\n */\nconst S3_ERRORS: Readonly<Record<string, { status: number; code: string; detail: string }>> = {\n    EntityTooLarge: {\n        status: 413,\n        code: \"FILE_TOO_LARGE\",\n        detail: \"Arquivo maior que o permitido.\",\n    },\n    EntityTooSmall: {\n        status: 400,\n        code: \"FILE_TOO_SMALL\",\n        detail: \"Arquivo menor que o permitido.\",\n    },\n    AccessDenied: {\n        status: 403,\n        code: \"SIGNED_URL_INVALID\",\n        detail: \"O link de envio não aceita este arquivo.\",\n    },\n};\n\nconst EXPIRED_POLICY = /policy expired/i;\n\n/**\n * Text of the first `<tag>` element in an S3 XML error body.\n *\n * @param xml - The response body.\n * @param tag - Element name.\n * @returns The element text, or `undefined` when absent.\n */\nfunction xmlText(xml: string, tag: string): string | undefined {\n    return new RegExp(`<${tag}>([^<]*)</${tag}>`).exec(xml)?.[1];\n}\n\n/**\n * Rewrite an S3 XML error into the local backend's code and status.\n *\n * A JSON envelope from the local backend already carries `code` and passes\n * through untouched, as does any failure without an XML body (network, abort).\n *\n * @param error - What the upload rejected with.\n * @returns The error to surface.\n */\nfunction normalizeError(error: unknown): unknown {\n    if (!(error instanceof TempestApiError) || typeof error.body !== \"string\") return error;\n    const s3Code = xmlText(error.body, \"Code\");\n    if (!s3Code) return error;\n    const message = xmlText(error.body, \"Message\") ?? \"\";\n    const mapped =\n        s3Code === \"AccessDenied\" && EXPIRED_POLICY.test(message)\n            ? {\n                  status: 403,\n                  code: \"SIGNED_URL_EXPIRED\",\n                  detail: \"O link de envio expirou.\",\n              }\n            : (S3_ERRORS[s3Code] ?? { status: error.status, code: s3Code, detail: message });\n    return new TempestApiError({\n        status: mapped.status,\n        code: mapped.code,\n        detail: mapped.detail || error.detail,\n        requestId: xmlText(error.body, \"RequestId\") ?? error.requestId,\n        body: error.body,\n    });\n}\n\n/**\n * Upload a file straight to storage through a pre-signed `POST` form, with the\n * size ceiling the policy enforces.\n *\n * The form is built the way S3 requires: every `post.fields` entry in order,\n * the file last in the `file` part — S3 ignores whatever follows the file.\n *\n * The request carries **no** credential and no custom header: no\n * `Authorization`, no CSRF token, no `X-Request-ID`, no cookies. `post.url` is\n * usually the storage host, outside the API's origin, and the signature in\n * `fields` is the whole authorization. Without custom headers the request is a\n * CORS \"simple request\", so it does not depend on the bucket's CORS rules\n * allowing a preflight.\n *\n * A file larger than `post.max_bytes` is refused before anything is sent, with\n * the same `413 FILE_TOO_LARGE` the server would answer. Server errors are\n * normalized into one `TempestApiError` whichever backend answered: the S3 XML\n * (`EntityTooLarge` → `FILE_TOO_LARGE`, `EntityTooSmall` → `FILE_TOO_SMALL`,\n * `AccessDenied` → `SIGNED_URL_INVALID`, or `SIGNED_URL_EXPIRED` when the policy\n * expired) or the local backend's JSON envelope, which already uses those codes.\n *\n * @example\n * const post = await api.post<PresignedPost>(\"/avatars/upload-form\");\n * await uploadPresignedPost(post, file, { onProgress: (p) => setProgress(p.fraction) });\n *\n * @param post - The form the API handed out.\n * @param file - The file or blob to upload.\n * @param options - Progress callback, abort signal and file name.\n * @returns Resolves when storage accepted the file (`204` on S3).\n * @throws TempestApiError On a refused upload, with the normalized `code`.\n */\nexport async function uploadPresignedPost(\n    post: PresignedPost,\n    file: Blob,\n    options: UploadPresignedPostOptions = {},\n): Promise<void> {\n    const { onProgress, signal, fileName } = options;\n    if (file.size > post.max_bytes) {\n        throw new TempestApiError({\n            status: 413,\n            code: \"FILE_TOO_LARGE\",\n            detail: `Arquivo de ${file.size} bytes excede o limite de ${post.max_bytes} bytes.`,\n        });\n    }\n\n    const form = new FormData();\n    for (const [name, value] of Object.entries(post.fields)) form.append(name, value);\n    if (fileName !== undefined) form.append(\"file\", file, fileName);\n    else form.append(\"file\", file);\n\n    try {\n        await uploadWithProgress({\n            url: post.url,\n            body: form,\n            method: \"POST\",\n            requestId: () => \"\",\n            withCredentials: false,\n            onProgress,\n            signal,\n            parser: () => undefined,\n        });\n    } catch (error) {\n        throw normalizeError(error);\n    }\n}\n"],"mappings":"A,wEAyCA,IAAMI,EAAwF,CAC1F,eAAgB,CACZ,OAAQ,IACR,KAAM,iBACN,OAAQ,gCACZ,EACA,eAAgB,CACZ,OAAQ,IACR,KAAM,iBACN,OAAQ,gCACZ,EACA,aAAc,CACV,OAAQ,IACR,KAAM,qBACN,OAAQ,0CACZ,CACJ,EAEMC,EAAiB,kBASvB,SAASC,EAAQ,EAAa,EAAiC,CAC3D,OAAW,OAAO,IAAIC,EAAI,YAAYA,EAAI,EAAE,CAAC,CAAC,KAAKC,CAAG,CAAC,GAAG,EAC9D,CAWA,SAASC,EAAe,EAAyB,CAC7C,GAAI,EAAEC,aAAiBV,EAAAA,kBAAoB,OAAOU,EAAM,MAAS,SAAU,OAAOA,EAClF,IAAMC,EAASL,EAAQI,EAAM,KAAM,MAAM,EACzC,GAAI,CAACC,EAAQ,OAAOD,EACpB,IAAME,EAAUN,EAAQI,EAAM,KAAM,SAAS,GAAK,GAC5CG,EACFF,IAAW,gBAAkBN,EAAe,KAAKO,CAAO,EAClD,CACI,OAAQ,IACR,KAAM,qBACN,OAAQ,0BACZ,EACCR,EAAUO,IAAW,CAAE,OAAQD,EAAM,OAAQ,KAAMC,EAAQ,OAAQC,CAAQ,EACtF,OAAO,IAAIZ,EAAAA,gBAAgB,CACvB,OAAQa,EAAO,OACf,KAAMA,EAAO,KACb,OAAQA,EAAO,QAAUH,EAAM,OAC/B,UAAWJ,EAAQI,EAAM,KAAM,WAAW,GAAKA,EAAM,UACrD,KAAMA,EAAM,IAChB,CAAC,CACL,CAiCA,eAAsBI,EAClB,EACA,EACA,EAAsC,CAAC,EAC1B,CACb,GAAM,CAAE,aAAY,SAAQ,YAAaC,EACzC,GAAIC,EAAK,KAAOC,EAAK,UACjB,MAAM,IAAIjB,EAAAA,gBAAgB,CACtB,OAAQ,IACR,KAAM,iBACN,OAAQ,cAAcgB,EAAK,KAAK,4BAA4BC,EAAK,UAAU,QAC/E,CAAC,EAGL,IAAMC,EAAO,IAAI,SACjB,IAAK,GAAM,CAACC,EAAMC,KAAU,OAAO,QAAQH,EAAK,MAAM,EAAGC,EAAK,OAAOC,EAAMC,CAAK,EAC5EC,IAAa,IAAA,GACZH,EAAK,OAAO,OAAQF,CAAI,EADDE,EAAK,OAAO,OAAQF,EAAMK,CAAQ,EAG9D,GAAI,CACA,MAAMpB,EAAAA,mBAAmB,CACrB,IAAKgB,EAAK,IACV,KAAMC,EACN,OAAQ,OACR,cAAiB,GACjB,gBAAiB,GACjB,aACA,SACA,WAAc,IAAA,EAClB,CAAC,CACL,OAASR,EAAO,CACZ,MAAMD,EAAeC,CAAK,CAC9B,CACJ,C"}

package/dist/http/presigned-post.js

@@ -0,0 +1,73 @@
+import { TempestApiError as e } from "./errors.js";
+import { uploadWithProgress as t } from "./upload-with-progress.js";
+//#region src/http/presigned-post.ts
+var n = {
+	EntityTooLarge: {
+		status: 413,
+		code: "FILE_TOO_LARGE",
+		detail: "Arquivo maior que o permitido."
+	},
+	EntityTooSmall: {
+		status: 400,
+		code: "FILE_TOO_SMALL",
+		detail: "Arquivo menor que o permitido."
+	},
+	AccessDenied: {
+		status: 403,
+		code: "SIGNED_URL_INVALID",
+		detail: "O link de envio não aceita este arquivo."
+	}
+}, r = /policy expired/i;
+function i(e, t) {
+	return RegExp(`<${t}>([^<]*)</${t}>`).exec(e)?.[1];
+}
+function a(t) {
+	if (!(t instanceof e) || typeof t.body != "string") return t;
+	let a = i(t.body, "Code");
+	if (!a) return t;
+	let o = i(t.body, "Message") ?? "", s = a === "AccessDenied" && r.test(o) ? {
+		status: 403,
+		code: "SIGNED_URL_EXPIRED",
+		detail: "O link de envio expirou."
+	} : n[a] ?? {
+		status: t.status,
+		code: a,
+		detail: o
+	};
+	return new e({
+		status: s.status,
+		code: s.code,
+		detail: s.detail || t.detail,
+		requestId: i(t.body, "RequestId") ?? t.requestId,
+		body: t.body
+	});
+}
+async function o(n, r, i = {}) {
+	let { onProgress: o, signal: s, fileName: c } = i;
+	if (r.size > n.max_bytes) throw new e({
+		status: 413,
+		code: "FILE_TOO_LARGE",
+		detail: `Arquivo de ${r.size} bytes excede o limite de ${n.max_bytes} bytes.`
+	});
+	let l = new FormData();
+	for (let [e, t] of Object.entries(n.fields)) l.append(e, t);
+	c === void 0 ? l.append("file", r) : l.append("file", r, c);
+	try {
+		await t({
+			url: n.url,
+			body: l,
+			method: "POST",
+			requestId: () => "",
+			withCredentials: !1,
+			onProgress: o,
+			signal: s,
+			parser: () => void 0
+		});
+	} catch (e) {
+		throw a(e);
+	}
+}
+//#endregion
+export { o as uploadPresignedPost };
+
+//# sourceMappingURL=presigned-post.js.map

package/dist/http/presigned-post.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"presigned-post.js","names":["S3_ERRORS","EXPIRED_POLICY","xmlText","tag","xml","normalizeError","error","TempestApiError","s3Code","message","mapped","uploadPresignedPost","options","file","post","form","name","value","fileName","uploadWithProgress"],"sources":["../../src/http/presigned-post.ts"],"sourcesContent":["import { TempestApiError } from \"./errors\";\nimport { uploadWithProgress } from \"./upload-with-progress\";\nimport type { UploadProgressEvent } from \"./upload-with-progress\";\n\n/**\n * A pre-signed `POST` form, as `tempest-fastapi-sdk` >= 0.331.0 hands it out\n * (`presigned_post_policy` / `SubjectObjectStorage.presign_post`).\n *\n * Snake case on purpose: this is the wire shape, so it parses straight from the\n * response of the app's own route.\n */\nexport interface PresignedPost {\n    /** Where the form is posted: the bucket on S3/MinIO, or the API itself on the local backend. */\n    url: string;\n    /** Form fields to send before the file, in this order — `key`, `policy`, signature and the rest. */\n    fields: Record<string, string>;\n    /** Largest file the policy accepts, in bytes. */\n    max_bytes: number;\n}\n\nexport interface UploadPresignedPostOptions {\n    /** Called on every `progress` event of the upload. */\n    onProgress?: (event: UploadProgressEvent) => void;\n    /** Abort the upload; rejects with an `AbortError` `DOMException`. */\n    signal?: AbortSignal;\n    /** File name sent with the `file` part. Defaults to `file.name` for a `File`. */\n    fileName?: string;\n}\n\n/**\n * S3 error codes mapped to the codes the local storage backend of\n * `tempest-fastapi-sdk` answers with, so one `code` reaches the UI whichever\n * backend the service is configured with.\n *\n * Statuses follow the local backend too: S3 answers `EntityTooLarge` with `400`,\n * the local backend `FILE_TOO_LARGE` with `413`. Measured against MinIO\n * `RELEASE.2025-04-22T22-12-26Z` from Chrome, cross-origin: the XML error body is\n * readable (MinIO sends CORS headers on errors), an expired policy and a broken\n * condition are both `AccessDenied` and differ only in the message\n * (`Policy expired` / `Policy Condition failed`).\n */\nconst S3_ERRORS: Readonly<Record<string, { status: number; code: string; detail: string }>> = {\n    EntityTooLarge: {\n        status: 413,\n        code: \"FILE_TOO_LARGE\",\n        detail: \"Arquivo maior que o permitido.\",\n    },\n    EntityTooSmall: {\n        status: 400,\n        code: \"FILE_TOO_SMALL\",\n        detail: \"Arquivo menor que o permitido.\",\n    },\n    AccessDenied: {\n        status: 403,\n        code: \"SIGNED_URL_INVALID\",\n        detail: \"O link de envio não aceita este arquivo.\",\n    },\n};\n\nconst EXPIRED_POLICY = /policy expired/i;\n\n/**\n * Text of the first `<tag>` element in an S3 XML error body.\n *\n * @param xml - The response body.\n * @param tag - Element name.\n * @returns The element text, or `undefined` when absent.\n */\nfunction xmlText(xml: string, tag: string): string | undefined {\n    return new RegExp(`<${tag}>([^<]*)</${tag}>`).exec(xml)?.[1];\n}\n\n/**\n * Rewrite an S3 XML error into the local backend's code and status.\n *\n * A JSON envelope from the local backend already carries `code` and passes\n * through untouched, as does any failure without an XML body (network, abort).\n *\n * @param error - What the upload rejected with.\n * @returns The error to surface.\n */\nfunction normalizeError(error: unknown): unknown {\n    if (!(error instanceof TempestApiError) || typeof error.body !== \"string\") return error;\n    const s3Code = xmlText(error.body, \"Code\");\n    if (!s3Code) return error;\n    const message = xmlText(error.body, \"Message\") ?? \"\";\n    const mapped =\n        s3Code === \"AccessDenied\" && EXPIRED_POLICY.test(message)\n            ? {\n                  status: 403,\n                  code: \"SIGNED_URL_EXPIRED\",\n                  detail: \"O link de envio expirou.\",\n              }\n            : (S3_ERRORS[s3Code] ?? { status: error.status, code: s3Code, detail: message });\n    return new TempestApiError({\n        status: mapped.status,\n        code: mapped.code,\n        detail: mapped.detail || error.detail,\n        requestId: xmlText(error.body, \"RequestId\") ?? error.requestId,\n        body: error.body,\n    });\n}\n\n/**\n * Upload a file straight to storage through a pre-signed `POST` form, with the\n * size ceiling the policy enforces.\n *\n * The form is built the way S3 requires: every `post.fields` entry in order,\n * the file last in the `file` part — S3 ignores whatever follows the file.\n *\n * The request carries **no** credential and no custom header: no\n * `Authorization`, no CSRF token, no `X-Request-ID`, no cookies. `post.url` is\n * usually the storage host, outside the API's origin, and the signature in\n * `fields` is the whole authorization. Without custom headers the request is a\n * CORS \"simple request\", so it does not depend on the bucket's CORS rules\n * allowing a preflight.\n *\n * A file larger than `post.max_bytes` is refused before anything is sent, with\n * the same `413 FILE_TOO_LARGE` the server would answer. Server errors are\n * normalized into one `TempestApiError` whichever backend answered: the S3 XML\n * (`EntityTooLarge` → `FILE_TOO_LARGE`, `EntityTooSmall` → `FILE_TOO_SMALL`,\n * `AccessDenied` → `SIGNED_URL_INVALID`, or `SIGNED_URL_EXPIRED` when the policy\n * expired) or the local backend's JSON envelope, which already uses those codes.\n *\n * @example\n * const post = await api.post<PresignedPost>(\"/avatars/upload-form\");\n * await uploadPresignedPost(post, file, { onProgress: (p) => setProgress(p.fraction) });\n *\n * @param post - The form the API handed out.\n * @param file - The file or blob to upload.\n * @param options - Progress callback, abort signal and file name.\n * @returns Resolves when storage accepted the file (`204` on S3).\n * @throws TempestApiError On a refused upload, with the normalized `code`.\n */\nexport async function uploadPresignedPost(\n    post: PresignedPost,\n    file: Blob,\n    options: UploadPresignedPostOptions = {},\n): Promise<void> {\n    const { onProgress, signal, fileName } = options;\n    if (file.size > post.max_bytes) {\n        throw new TempestApiError({\n            status: 413,\n            code: \"FILE_TOO_LARGE\",\n            detail: `Arquivo de ${file.size} bytes excede o limite de ${post.max_bytes} bytes.`,\n        });\n    }\n\n    const form = new FormData();\n    for (const [name, value] of Object.entries(post.fields)) form.append(name, value);\n    if (fileName !== undefined) form.append(\"file\", file, fileName);\n    else form.append(\"file\", file);\n\n    try {\n        await uploadWithProgress({\n            url: post.url,\n            body: form,\n            method: \"POST\",\n            requestId: () => \"\",\n            withCredentials: false,\n            onProgress,\n            signal,\n            parser: () => undefined,\n        });\n    } catch (error) {\n        throw normalizeError(error);\n    }\n}\n"],"mappings":";;;AAyCA,IAAMA,IAAwF;CAC1F,gBAAgB;EACZ,QAAQ;EACR,MAAM;EACN,QAAQ;CACZ;CACA,gBAAgB;EACZ,QAAQ;EACR,MAAM;EACN,QAAQ;CACZ;CACA,cAAc;EACV,QAAQ;EACR,MAAM;EACN,QAAQ;CACZ;AACJ,GAEMC,IAAiB;AASvB,SAASC,EAAQ,GAAa,GAAiC;CAC3D,OAAW,OAAO,IAAIC,EAAI,YAAYA,EAAI,EAAE,CAAC,CAAC,KAAKC,CAAG,CAAC,GAAG;AAC9D;AAWA,SAASC,EAAe,GAAyB;CAC7C,IAAI,EAAEC,aAAiBC,MAAoB,OAAOD,EAAM,QAAS,UAAU,OAAOA;CAClF,IAAME,IAASN,EAAQI,EAAM,MAAM,MAAM;CACzC,IAAI,CAACE,GAAQ,OAAOF;CACpB,IAAMG,IAAUP,EAAQI,EAAM,MAAM,SAAS,KAAK,IAC5CI,IACFF,MAAW,kBAAkBP,EAAe,KAAKQ,CAAO,IAClD;EACI,QAAQ;EACR,MAAM;EACN,QAAQ;CACZ,IACCT,EAAUQ,MAAW;EAAE,QAAQF,EAAM;EAAQ,MAAME;EAAQ,QAAQC;CAAQ;CACtF,OAAO,IAAIF,EAAgB;EACvB,QAAQG,EAAO;EACf,MAAMA,EAAO;EACb,QAAQA,EAAO,UAAUJ,EAAM;EAC/B,WAAWJ,EAAQI,EAAM,MAAM,WAAW,KAAKA,EAAM;EACrD,MAAMA,EAAM;CAChB,CAAC;AACL;AAiCA,eAAsBK,EAClB,GACA,GACA,IAAsC,CAAC,GAC1B;CACb,IAAM,EAAE,eAAY,WAAQ,gBAAaC;CACzC,IAAIC,EAAK,OAAOC,EAAK,WACjB,MAAM,IAAIP,EAAgB;EACtB,QAAQ;EACR,MAAM;EACN,QAAQ,cAAcM,EAAK,KAAK,4BAA4BC,EAAK,UAAU;CAC/E,CAAC;CAGL,IAAMC,IAAO,IAAI,SAAS;CAC1B,KAAK,IAAM,CAACC,GAAMC,MAAU,OAAO,QAAQH,EAAK,MAAM,GAAG,EAAK,OAAOE,GAAMC,CAAK;CAChF,AAAIC,MAAa,KAAA,IACZH,EAAK,OAAO,QAAQF,CAAI,IADDE,EAAK,OAAO,QAAQF,GAAMK,CAAQ;CAG9D,IAAI;EACA,MAAMC,EAAmB;GACrB,KAAKL,EAAK;GACV,MAAMC;GACN,QAAQ;GACR,iBAAiB;GACjB,iBAAiB;GACjB;GACA;GACA,cAAc,KAAA;EAClB,CAAC;CACL,SAAST,GAAO;EACZ,MAAMD,EAAeC,CAAK;CAC9B;AACJ"}