@brftech/filex-core 0.42.1 → 0.43.0

package/src/composables/useS3Keys.ts

@@ -17,6 +17,7 @@ import type { ExplorerConfig } from '../types/ExplorerConfig';
 import type { S3AccessKey, S3Connection, S3KeyCreated, S3KeyRequest } from '../types/S3Keys';
 import { connectionsBase } from './useConnections';
 import { useFileApi } from './useFileApi';
+import { serverWords } from '../lib/errorWords';
 
 export function useS3Keys(config: ExplorerConfig) {
   const api = useFileApi(config);
@@ -28,6 +29,9 @@ export function useS3Keys(config: ExplorerConfig) {
   const loading = ref(false);
   const loaded = ref(false);
   const error = ref<string | null>(null);
+  /** The fix, when the server told THIS caller one (`admin_hint`: only an
+   *  administrator who can act on it is sent it). */
+  const errorHint = ref<string | null>(null);
   /**
    * null until the first load answers. False means the caller may not mint
    * keys (anonymous, or a token without the right to) — the guide is still
@@ -38,19 +42,15 @@ export function useS3Keys(config: ExplorerConfig) {
   /** The secret, held in memory for exactly as long as the user is looking. */
   const revealed = ref<S3KeyCreated | null>(null);
 
+  /** A refusal, said — lib/errorWords `serverWords`, the one rule every
+   *  connection panel shares (it used to print the server's `error` field as
+   *  it came: an environment variable, to a regular user). ⚠ The locale is
+   *  passed because what comes back may be the SERVER's own sentence: it
+   *  never met a translator, and an Arabic panel needs its machine runs
+   *  isolated (lib/direction `foreignText`). */
   function messageOf(e: unknown): string {
-    const err = e as { message?: string; detail?: string } | null;
-    // The backend's own words beat a status line: "access keys are not
-    // available on this install" tells an operator what to fix; "503" does not.
-    if (err?.detail) {
-      try {
-        const parsed = JSON.parse(err.detail) as { error?: string };
-        if (parsed?.error) return parsed.error;
-      } catch {
-        /* not JSON — fall through */
-      }
-    }
-    return err?.message || String(e);
+    errorHint.value = (e as { hint?: string } | null)?.hint ?? null;
+    return serverWords(e, config.locale);
   }
 
   function statusOf(e: unknown): number | undefined {
@@ -60,6 +60,7 @@ export function useS3Keys(config: ExplorerConfig) {
   async function load(): Promise<void> {
     loading.value = true;
     error.value = null;
+    errorHint.value = null;
     try {
       const body = await api.jsonFetch<{ keys: S3AccessKey[] } & S3Connection>(
         url('/api/auth/s3-keys'),
@@ -93,6 +94,7 @@ export function useS3Keys(config: ExplorerConfig) {
    */
   async function create(req: S3KeyRequest): Promise<S3KeyCreated | null> {
     error.value = null;
+    errorHint.value = null;
     try {
       const body = await api.jsonFetch<S3KeyCreated>(url('/api/auth/s3-keys'), {
         method: 'POST',
@@ -117,6 +119,7 @@ export function useS3Keys(config: ExplorerConfig) {
 
   async function setDisabled(id: number, disabled: boolean): Promise<void> {
     error.value = null;
+    errorHint.value = null;
     try {
       await api.jsonFetch(url(`/api/auth/s3-keys/${id}/state`), {
         method: 'POST',
@@ -131,6 +134,7 @@ export function useS3Keys(config: ExplorerConfig) {
 
   async function remove(id: number): Promise<void> {
     error.value = null;
+    errorHint.value = null;
     try {
       await api.jsonFetch(url(`/api/auth/s3-keys/${id}`), { method: 'DELETE' });
       // A revealed secret belonging to the key just revoked must go with it.
@@ -163,6 +167,7 @@ export function useS3Keys(config: ExplorerConfig) {
     loading,
     loaded,
     error,
+    errorHint,
     canMint,
     revealed,
     guideKey,

package/src/composables/useSSHKeys.ts

@@ -16,6 +16,7 @@ import type { ExplorerConfig } from '../types/ExplorerConfig';
 import type { SSHConnection, SSHPublicKey } from '../types/SSHKeys';
 import { connectionsBase } from './useConnections';
 import { useFileApi } from './useFileApi';
+import { serverWords } from '../lib/errorWords';
 
 export function useSSHKeys(config: ExplorerConfig) {
   const api = useFileApi(config);
@@ -29,17 +30,14 @@ export function useSSHKeys(config: ExplorerConfig) {
   const error = ref<string | null>(null);
   const canAdd = ref<boolean | null>(null);
 
+  /** A refusal, said — lib/errorWords `serverWords`, the one rule every
+   *  connection panel shares (it used to print the server's `error` field as
+   *  it came: an environment variable, to a regular user). ⚠ The locale is
+   *  passed because what comes back may be the SERVER's own sentence: it
+   *  never met a translator, and an Arabic panel needs its machine runs
+   *  isolated (lib/direction `foreignText`). */
   function messageOf(e: unknown): string {
-    const err = e as { message?: string; detail?: string } | null;
-    if (err?.detail) {
-      try {
-        const parsed = JSON.parse(err.detail) as { error?: string };
-        if (parsed?.error) return parsed.error;
-      } catch {
-        /* not JSON */
-      }
-    }
-    return err?.message || String(e);
+    return serverWords(e, config.locale);
   }
 
   function statusOf(e: unknown): number | undefined {

package/src/composables/useTokens.ts

@@ -20,6 +20,7 @@ import type { ExplorerConfig } from '../types/ExplorerConfig';
 import type { ApiToken, ApiTokenCreated, ApiTokenRequest } from '../types/Tokens';
 import { connectionsBase } from './useConnections';
 import { useFileApi } from './useFileApi';
+import { serverWords } from '../lib/errorWords';
 
 export function useTokens(config: ExplorerConfig) {
   const api = useFileApi(config);
@@ -40,19 +41,14 @@ export function useTokens(config: ExplorerConfig) {
   /** The secret, held in memory for exactly as long as the user is looking. */
   const revealed = ref<ApiTokenCreated | null>(null);
 
+  /** A refusal, said — lib/errorWords `serverWords`, the one rule every
+   *  connection panel shares (it used to print the server's `error` field as
+   *  it came: an environment variable, to a regular user). ⚠ The locale is
+   *  passed because what comes back may be the SERVER's own sentence: it
+   *  never met a translator, and an Arabic panel needs its machine runs
+   *  isolated (lib/direction `foreignText`). */
   function messageOf(e: unknown): string {
-    const err = e as { message?: string; detail?: string } | null;
-    // The backend's own words beat a status line: "scope 'admin' is not
-    // available here" tells the user what to change; "403" does not.
-    if (err?.detail) {
-      try {
-        const parsed = JSON.parse(err.detail) as { error?: string };
-        if (parsed?.error) return parsed.error;
-      } catch {
-        /* not JSON — fall through */
-      }
-    }
-    return err?.message || String(e);
+    return serverWords(e, config.locale);
   }
 
   function statusOf(e: unknown): number | undefined {

package/src/composables/useUploadChunked.ts

@@ -36,6 +36,12 @@
 
 import type { ExplorerConfig } from '../types/ExplorerConfig';
 import type { FileApi } from './useFileApi';
+import { networkFailure, requestFailure, wordsIn } from '../lib/errorWords';
+// ⚠ An upload is an ACTION: it is never folded into the shared "no
+// connection" notice, because the person is waiting to be told whether their
+// file went (lib/connection).
+import { noteRequestFailed, noteRequestSucceeded } from '../lib/connection';
+import { resolveLocale } from '../locales/resolve';
 import {
   clearResume,
   defaultResumeStorage,
@@ -367,7 +373,12 @@ export function useUploadChunked(
         }
         if (next === -2) continue; // offset moved under us; re-slice
         if (next < 0) throw lastErr ?? new Error('chunk upload failed');
-        if (next <= acked) throw new Error(`upload stalled at byte ${acked}`);
+        // Said, not "upload stalled at byte 8388608": the row is read by a
+        // person, and the byte count is only for whoever is debugging.
+        if (next <= acked) {
+          console.warn('[filex] upload stalled at byte', acked);
+          throw new Error(wordsIn(resolveLocale(config.locale))('err.upload_stalled'));
+        }
         acked = next;
         report();
         saveResume(storage, key, {
@@ -455,6 +466,7 @@ export function useUploadChunked(
         };
         xhr.onload = () => {
           inFlight = null;
+          noteRequestSucceeded();
           if (xhr.status >= 200 && xhr.status < 300) {
             try {
               const body = JSON.parse(xhr.responseText) as StatusResponse;
@@ -466,16 +478,14 @@ export function useUploadChunked(
             }
             return;
           }
-          const err = new Error(
-            `chunk ${start}-${end - 1} → ${xhr.status}`,
-          ) as Error & { status?: number; detail?: string };
-          err.status = xhr.status;
-          err.detail = xhr.responseText.slice(0, 200);
-          reject(err);
+          // Said (lib/errorWords): the upload row used to read
+          // "chunk 0-8388607 → 500". Status and body still ride along.
+          reject(requestFailure(xhr.status, xhr.responseText || '', resolveLocale(config.locale)));
         };
         xhr.onerror = () => {
           inFlight = null;
-          reject(new Error(`chunk ${start}-${end - 1}: network error`));
+          noteRequestFailed('action');
+          reject(networkFailure(resolveLocale(config.locale)));
         };
         xhr.onabort = () => {
           inFlight = null;

package/src/composables/useViewerFetch.ts

@@ -12,6 +12,8 @@
  * doesn't reject the request when the viewer fetches the file body
  * directly (instead of letting the browser do it via `<img src>` etc).
  */
+import { requestFailure } from '../lib/errorWords';
+
 export interface ViewerFetchOptions {
   url: string;
   headers?: Record<string, string>;
@@ -26,10 +28,11 @@ async function fetchOk(opts: ViewerFetchOptions): Promise<Response> {
     signal: opts.signal,
   });
   if (!res.ok) {
+    // Said, not printed (lib/errorWords): the viewers used to show
+    // "404 Not Found — {…}" in the pane. The viewer re-says it in its own
+    // language through `sayFailure(err, …, { t })`.
     const text = await res.text().catch(() => '');
-    throw new Error(
-      `${res.status} ${res.statusText}${text ? ' — ' + text.slice(0, 200) : ''}`,
-    );
+    throw requestFailure(res.status, text, undefined);
   }
   return res;
 }