mirror of
https://github.com/yusufipk/OpenFrame.git
synced 2026-09-11 09:36:08 +00:00
yusufipek
6561e0817e
Being told "storage limit exceeded" when the limit is the free trial's three gigabytes is a dead end. The account is not full because it stores a lot; it is capped because it has not subscribed, and deleting files buys back very little. The refusal now says which ceiling it is and carries its own error code, so the toast can offer a link to the billing settings on the trial ceiling and stay quiet on the paid one, where subscribing changes nothing. The code had to survive the trip to the toast, which meant the upload helpers throwing something that carries it rather than a bare Error. Two places were dropping the server's message on the floor entirely: adding a version reported "Failed to initialize upload" whatever the server said, and every asset upload in the pane rewrote its own failure text.
102 lines
3.3 KiB
TypeScript
102 lines
3.3 KiB
TypeScript
// What a failed API call is worth showing the person who made it.
|
|
//
|
|
// Every route answers with `{ error, code? }`, and the code is the part that
|
|
// says whether there is anything the caller can do. Losing it on the way to a
|
|
// toast is how a full trial account ends up reading "Failed to upload" and
|
|
// trying the same upload again.
|
|
|
|
import { toast } from 'sonner';
|
|
|
|
/** The machine-readable half of an error response. Mirrors ErrorCode in lib/api-response.ts. */
|
|
export const API_ERROR_CODES = {
|
|
/** Out of room because the account has not subscribed, not because the plan is full. */
|
|
TRIAL_STORAGE_LIMIT_EXCEEDED: 'TRIAL_STORAGE_LIMIT_EXCEEDED',
|
|
} as const;
|
|
|
|
export interface ApiErrorPayload {
|
|
error?: string;
|
|
code?: string;
|
|
}
|
|
|
|
/**
|
|
* A failure that came back from our own API, with the code still attached.
|
|
*
|
|
* The upload helpers throw rather than return, so without this the code is gone
|
|
* by the time anything is in a position to show it.
|
|
*/
|
|
export class ApiRequestError extends Error {
|
|
readonly code: string | null;
|
|
|
|
constructor(message: string, code?: string | null) {
|
|
super(message);
|
|
this.name = 'ApiRequestError';
|
|
this.code = code ?? null;
|
|
}
|
|
}
|
|
|
|
/** Builds the error to throw from a parsed `{ error, code }` body. */
|
|
export function apiRequestError(
|
|
payload: ApiErrorPayload | null,
|
|
fallback: string
|
|
): ApiRequestError {
|
|
return new ApiRequestError(payload?.error || fallback, payload?.code);
|
|
}
|
|
|
|
function codeOf(source: unknown): string | null {
|
|
if (source instanceof ApiRequestError) return source.code;
|
|
if (source && typeof source === 'object' && 'code' in source) {
|
|
const code = (source as ApiErrorPayload).code;
|
|
return typeof code === 'string' ? code : null;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
function messageOf(source: unknown, fallback: string): string {
|
|
if (source instanceof Error) return source.message || fallback;
|
|
if (source && typeof source === 'object' && 'error' in source) {
|
|
const message = (source as ApiErrorPayload).error;
|
|
if (typeof message === 'string' && message) return message;
|
|
}
|
|
return fallback;
|
|
}
|
|
|
|
export interface ToastApiErrorOptions {
|
|
/** Prepended as `${prefix}: ${message}`, for per-file failures in a batch. */
|
|
prefix?: string;
|
|
}
|
|
|
|
/**
|
|
* Shows an API failure, with a way out attached when there is one.
|
|
*
|
|
* Takes either a parsed response body or a thrown error, so the same call works
|
|
* whether the caller checked `res.ok` itself or caught what an upload helper
|
|
* threw. On the trial storage ceiling it adds a link to the billing settings,
|
|
* because subscribing is the only thing that makes the upload possible and the
|
|
* uploader has no way to know that from "storage limit exceeded".
|
|
*/
|
|
export function toastApiError(
|
|
source: unknown,
|
|
fallback: string,
|
|
options: ToastApiErrorOptions = {}
|
|
): void {
|
|
const message = messageOf(source, fallback);
|
|
const text = options.prefix ? `${options.prefix}: ${message}` : message;
|
|
|
|
if (codeOf(source) === API_ERROR_CODES.TRIAL_STORAGE_LIMIT_EXCEEDED) {
|
|
toast.error(text, {
|
|
// Longer than a plain error: this one is asking for a decision rather than
|
|
// just reporting, and it disappears under the cursor at the usual timing.
|
|
duration: 12000,
|
|
action: {
|
|
label: 'See plans',
|
|
onClick: () => {
|
|
window.location.href = '/settings';
|
|
},
|
|
},
|
|
});
|
|
return;
|
|
}
|
|
|
|
toast.error(text);
|
|
}
|