@alxia/react-router 0.9.0 → 0.11.0

package/dist/errors/index.js

@@ -0,0 +1,602 @@
+// src/errors/api-error.ts
+var isNamed = (error, name) => error instanceof Error && error.name === name;
+function isApiErrorLike(error) {
+  return isNamed(error, "ApiError") && Array.isArray(error.errors) && typeof error.status === "number";
+}
+function waitMinutes(extensions) {
+  const minutes = extensions?.params?.minutes ?? extensions?.minutes;
+  if (minutes !== undefined)
+    return Math.max(1, Number(minutes) || 1);
+  const seconds = extensions?.params?.retryAfter ?? extensions?.retryAfter;
+  return Math.max(1, Math.ceil(Number(seconds) / 60) || 1);
+}
+function valuesOf(extensions) {
+  if (!extensions)
+    return;
+  return extensions.params ? { ...extensions, ...extensions.params } : extensions;
+}
+var isStatusError = (error) => isNamed(error, "ApiStatusError") && typeof error.status === "number";
+var isUnavailableError = (error) => isNamed(error, "ApiUnavailableError") && typeof error.reason === "string";
+// src/errors/code-resolver.ts
+var API_CODE = /^[a-z-]+\.errors\.[a-z0-9-]+$/;
+function paramsCode(issue) {
+  const code = issue.params?.code;
+  return typeof code === "string" ? code : undefined;
+}
+function apiCodeResolver(messages, options) {
+  const isApiCode = (key) => options.isApiCode ? options.isApiCode(key) : API_CODE.test(key);
+  return {
+    translate(key, context, provideLanguage) {
+      if (!isApiCode(key))
+        return options.translate(key, context, provideLanguage);
+      const language = typeof provideLanguage === "function" ? provideLanguage() : provideLanguage ?? options.language();
+      return messages.apiMessage(key, context, language) ?? key;
+    },
+    codeOf(issue) {
+      return options.codeOf ? options.codeOf(issue) : paramsCode(issue);
+    }
+  };
+}
+
+// src/errors/describe-refusal.ts
+function refusalOf(errors, error, language) {
+  if (isApiErrorLike(error)) {
+    return {
+      message: errors.apiErrorMessage(error, language),
+      status: error.status
+    };
+  }
+  if (error instanceof Response && error.status === 503) {
+    return { message: errors.unavailableMessage(language), status: 503 };
+  }
+  return;
+}
+function fieldErrorsOf(errors, error, language) {
+  const extensions = error.errors[0]?.extensions;
+  const fields = Array.isArray(extensions?.fields) ? extensions.fields : [];
+  if (!fields.length && extensions?.field) {
+    return { [extensions.field]: errors.apiErrorMessage(error, language) };
+  }
+  return Object.fromEntries(fields.map(({ path, code, message, params }) => [
+    path,
+    errors.translateCode(code, message, language, params)
+  ]));
+}
+
+// src/errors/fetcher-result.ts
+import { data as data2 } from "react-router";
+
+// src/errors/route-error.ts
+import { data } from "react-router";
+
+// src/errors/request-id.ts
+var REQUEST_ID_HEADER = "x-request-id";
+function requestIdOf(response) {
+  return response.headers.get(REQUEST_ID_HEADER) || undefined;
+}
+
+// src/errors/route-error.ts
+var ROUTED = new Set([401, 403, 404, 503]);
+function routeError(error, { statuses = ROUTED } = {}) {
+  if (isApiErrorLike(error)) {
+    const { requestId } = error;
+    if (statuses.has(error.status)) {
+      return data({ code: error.code, message: error.message, requestId }, { status: error.status });
+    }
+    return requestId ? data({ requestId }, { status: 500 }) : error;
+  }
+  if (error instanceof Response && statuses.has(error.status)) {
+    const requestId = requestIdOf(error);
+    if (requestId) {
+      return data({ requestId }, { status: error.status });
+    }
+  }
+  return error;
+}
+function errorRequestId(error) {
+  if (typeof error !== "object" || error === null)
+    return;
+  const { data: body } = error;
+  if (typeof body !== "object" || body === null)
+    return;
+  const { requestId } = body;
+  return typeof requestId === "string" && requestId ? requestId : undefined;
+}
+
+// src/errors/fetcher-result.ts
+function fetcherRefusal(errors, error, language, route) {
+  const refusal = isApiErrorLike(error) && error.status === 401 ? undefined : errors.apiRefusal(error, language);
+  if (!refusal)
+    throw routeError(error, route);
+  return refusal;
+}
+async function fetcherResult(errors, language, about, run, route) {
+  try {
+    return { ok: true, ...about, ...await run() };
+  } catch (error) {
+    const { message, status } = fetcherRefusal(errors, error, language, route);
+    return data2({ ok: false, ...about, error: message }, { status });
+  }
+}
+
+// src/errors/submit-form.ts
+import { data as data3 } from "react-router";
+async function submitForm(errors, language, run, fieldOf, route) {
+  try {
+    return { ok: true, value: await run() };
+  } catch (error) {
+    if (!isApiErrorLike(error) || error.status === 401) {
+      throw routeError(error, route);
+    }
+    const field = error.errors[0]?.extensions?.field;
+    if (error.status === 404 && !(field && fieldOf(field))) {
+      throw routeError(error, route);
+    }
+    const byField = {};
+    const unplaced = [];
+    for (const [path, message] of Object.entries(errors.fieldErrors(error, language))) {
+      const field = fieldOf(path);
+      if (field)
+        byField[field] = message;
+      else
+        unplaced.push(message);
+    }
+    const formError = Object.keys(byField).length && !unplaced.length ? undefined : [errors.apiErrorMessage(error, language), ...unplaced].join(" ");
+    return data3({ fieldErrors: byField, formError }, { status: error.status });
+  }
+}
+
+// src/errors/describe.ts
+function describeApiErrors({
+  messages,
+  unavailable,
+  refused,
+  byCode = {},
+  isApiCode = (code) => API_CODE.test(code)
+}) {
+  const translateCode = (code, fallback, language, values) => {
+    if (!code)
+      return fallback;
+    return messages.apiMessage(code, values, language) ?? fallback;
+  };
+  const apiErrorMessage = (error, language) => {
+    const code = error.code;
+    if (refused && (!code || !isApiCode(code)))
+      return refused(language);
+    const own = code && Object.hasOwn(byCode, code) ? byCode[code] : undefined;
+    if (own)
+      return own(error, language);
+    return translateCode(code, error.message, language, valuesOf(error.errors[0]?.extensions));
+  };
+  const unavailableMessage = (language) => unavailable(language);
+  const apiRefusal = (error, language) => refusalOf({ apiErrorMessage, unavailableMessage }, error, language);
+  const fieldErrors = (error, language) => fieldErrorsOf({ apiErrorMessage, translateCode }, error, language);
+  const parts = { apiRefusal, apiErrorMessage, fieldErrors };
+  return {
+    translateCode,
+    apiErrorMessage,
+    unavailableMessage,
+    fieldErrors,
+    apiRefusal,
+    fetcherRefusal: (error, language, route) => fetcherRefusal(parts, error, language, route),
+    fetcherResult: (language, about, run, route) => fetcherResult(parts, language, about, run, route),
+    submitForm: (language, run, fieldOf, route) => submitForm(parts, language, run, fieldOf, route)
+  };
+}
+
+// src/errors/api-errors.ts
+function createApiErrors(options) {
+  return describeApiErrors(options);
+}
+// src/errors/log.ts
+function quietLog(log, methods) {
+  const quiet = {};
+  for (const method of methods) {
+    quiet[method] = (...args) => {
+      try {
+        log[method](...args);
+      } catch {}
+    };
+  }
+  return quiet;
+}
+
+// src/errors/call-failure.ts
+var PASSED_THROUGH = new Set([401, 403, 404]);
+var NO_BODY = new Set([101, 204, 205, 304]);
+function apiCallFailure(error, {
+  api,
+  operation = "operation",
+  requestId,
+  signal,
+  passedThrough = PASSED_THROUGH,
+  log: appLog = console
+}) {
+  const log = quietLog(appLog, ["warn", "error"]);
+  const call = `${api}: ${operation}${requestId ? ` (request ${requestId})` : ""}`;
+  const headers = requestId ? { [REQUEST_ID_HEADER]: requestId } : {};
+  const unavailable = (reason, cause) => {
+    log.error(`${call} ${reason}`, cause ?? "");
+    return new Response(null, { status: 503, headers });
+  };
+  if (isApiErrorLike(error)) {
+    if (requestId)
+      error.requestId = requestId;
+    const line = `${call} answered ${error.status}${error.code ? ` ${error.code}` : ""}`;
+    if (error.status >= 500)
+      log.error(line);
+    else
+      log.warn(line);
+    return error;
+  }
+  if (isStatusError(error)) {
+    if (passedThrough.has(error.status)) {
+      log.warn(`${call} answered ${error.status}`);
+      const statusText = typeof error.statusText === "string" ? error.statusText : "";
+      if (NO_BODY.has(error.status)) {
+        return new Response(null, {
+          status: error.status,
+          statusText,
+          headers
+        });
+      }
+      return new Response(statusText, {
+        status: error.status,
+        statusText,
+        headers
+      });
+    }
+    return unavailable(`answered ${error.status} without GraphQL`, error.body);
+  }
+  if (isUnavailableError(error))
+    return unavailable(error.reason, error.cause);
+  if (signal?.aborted)
+    return unavailable("aborted", error);
+  return error;
+}
+function operationName(document) {
+  for (const definition of document.definitions) {
+    if (definition.kind === "OperationDefinition") {
+      return definition.name?.value ?? definition.operation ?? "operation";
+    }
+  }
+  return "operation";
+}
+// src/errors/catalogue-check.ts
+async function checkVersions({ reader, versions, ttl, retryMs, log }, now) {
+  try {
+    const latest = await versions();
+    for (const [language, entry] of [...reader.held]) {
+      if (latest[language] !== entry.version) {
+        await reader.load(language, now);
+      } else {
+        entry.checkedAt = now;
+      }
+    }
+  } catch (error) {
+    log.error("alxia-react-router: the error catalogue was not checked, keeping what is held", error);
+    for (const entry of reader.held.values()) {
+      entry.checkedAt = now - ttl() + retryMs;
+    }
+  }
+}
+function safeTtl(ttlMs, fallback, log) {
+  return () => {
+    try {
+      const ttl = typeof ttlMs === "function" ? ttlMs() : ttlMs;
+      if (typeof ttl === "number" && Number.isFinite(ttl) && ttl >= 0) {
+        return ttl;
+      }
+      log.error("alxia-react-router: ttlMs is not a duration, using retryMs");
+    } catch (error) {
+      log.error("alxia-react-router: ttlMs threw, using retryMs", error);
+    }
+    return fallback;
+  };
+}
+
+// src/errors/catalogue-read.ts
+async function boundedWait(pending, firstReadWaitMs) {
+  const left = firstReadWaitMs - (performance.now() - pending.started);
+  if (left <= 0)
+    return;
+  let timer;
+  const limit = new Promise((resolve) => {
+    timer = setTimeout(resolve, left);
+  });
+  await Promise.race([pending.read, limit]);
+  clearTimeout(timer);
+}
+function createCatalogueReader({
+  messages,
+  read,
+  retryMs,
+  firstReadWaitMs,
+  log
+}) {
+  const held = new Map;
+  const loading = new Map;
+  const failedAt = new Map;
+  async function load(language, now) {
+    const reply = await read(language);
+    const entries = Object.create(null);
+    for (const { code, message, params } of reply.messages) {
+      entries[code] = { message, params };
+    }
+    messages.set(language, entries);
+    held.set(language, { version: reply.version, checkedAt: now });
+  }
+  function loadOnce(language, now) {
+    let pending = loading.get(language);
+    if (!pending) {
+      const started = performance.now();
+      const reading = load(language, now).then(() => {
+        failedAt.delete(language);
+      }).catch((error) => {
+        failedAt.set(language, now + (performance.now() - started));
+        log.error(`alxia-react-router: the error catalogue (${language}) was not read`, error);
+      }).finally(() => {
+        loading.delete(language);
+      });
+      pending = { read: reading, started };
+      loading.set(language, pending);
+    }
+    return pending;
+  }
+  return {
+    held,
+    load,
+    async first(language, now) {
+      const failed = failedAt.get(language);
+      if (failed === undefined || now - failed >= retryMs) {
+        await boundedWait(loadOnce(language, now), firstReadWaitMs);
+      }
+    },
+    reset() {
+      held.clear();
+      loading.clear();
+      failedAt.clear();
+    }
+  };
+}
+
+// src/errors/catalogue.ts
+function clientMessages(messages, languages, clientCodes) {
+  const byLanguage = {};
+  for (const language of languages) {
+    const entries = Object.create(null);
+    for (const code of clientCodes) {
+      const entry = messages.messageOf(language, code);
+      if (entry)
+        entries[code] = entry;
+    }
+    byLanguage[language] = entries;
+  }
+  return byLanguage;
+}
+function createErrorCatalogue({
+  messages,
+  languages,
+  read,
+  versions,
+  ttlMs,
+  retryMs = 5000,
+  firstReadWaitMs = 1500,
+  clientCodes,
+  log: appLog = console
+}) {
+  if (languages.length === 0) {
+    throw new TypeError("createErrorCatalogue(): needs at least one language.");
+  }
+  const log = quietLog(appLog, ["error"]);
+  const ttl = safeTtl(ttlMs, retryMs, log);
+  const reader = createCatalogueReader({
+    messages,
+    read,
+    retryMs,
+    firstReadWaitMs,
+    log
+  });
+  const context = { reader, versions, ttl, retryMs, log };
+  let checking;
+  async function fresh(language, now = Date.now()) {
+    const entry = reader.held.get(language);
+    if (!entry)
+      return reader.first(language, now);
+    if (now - entry.checkedAt >= ttl() && !checking) {
+      checking = checkVersions(context, now).finally(() => {
+        checking = undefined;
+      }).catch(() => {});
+    }
+  }
+  const freshAll = async (now = Date.now()) => {
+    await Promise.all(languages.map((language) => fresh(language, now)));
+  };
+  return {
+    fresh,
+    freshAll,
+    warm() {
+      freshAll().catch((error) => {
+        log.error("alxia-react-router: the error catalogue was not warmed", error);
+      });
+    },
+    clientMessages: () => clientMessages(messages, languages, clientCodes),
+    reset() {
+      reader.reset();
+      checking = undefined;
+      messages.clear();
+    },
+    heldVersion: (language) => reader.held.get(language)?.version,
+    settled: () => checking ?? Promise.resolve()
+  };
+}
+// src/errors/json-actions.ts
+import { data as data4, redirect } from "react-router";
+
+// src/errors/page-path.ts
+function nextOf(url) {
+  const { pathname, searchParams } = new URL(url);
+  const trimmed = pathname.endsWith("/_.data") ? pathname.slice(0, -"_.data".length) : pathname.replace(/\.data$/, "");
+  const path = trimmed.replace(/^\/{2,}/, "/");
+  const params = new URLSearchParams(searchParams);
+  params.delete("_routes");
+  for (const value of params.getAll("index")) {
+    if (!value)
+      params.delete("index", value);
+  }
+  const search = params.toString();
+  return search ? `${path}?${search}` : path;
+}
+
+// src/errors/json-actions.ts
+function jsonActions(options = {}) {
+  const ownOrigin = (request) => {
+    const { origin } = options;
+    const set = typeof origin === "function" ? origin() : origin;
+    return set ?? new URL(request.url).origin;
+  };
+  const isJson = (request) => request.headers.get("content-type")?.startsWith("application/json");
+  async function readJson(request) {
+    const origin = request.headers.get("origin");
+    const site = request.headers.get("sec-fetch-site");
+    if (origin && origin !== ownOrigin(request) || site && site !== "same-origin" && site !== "none") {
+      throw data4("Cross-site request refused", { status: 403 });
+    }
+    if (!isJson(request)) {
+      throw data4("Expected a JSON body", { status: 415 });
+    }
+    return request.json().catch(() => {
+      throw data4("Malformed JSON body", { status: 400 });
+    });
+  }
+  return {
+    readJson,
+    requireJsonPost(request) {
+      if (!isJson(request))
+        throw redirect(nextOf(request.url));
+    },
+    async readInput(request, schema) {
+      const body = await readJson(request);
+      const result = await schema["~standard"].validate(body?.input);
+      if (result.issues) {
+        throw data4("The form sent an input the API would refuse", {
+          status: 400
+        });
+      }
+      return result.value;
+    }
+  };
+}
+// src/errors/message-values.ts
+var DAY = /^(\d{4})-(\d{2})-(\d{2})$/;
+function dayOf(value) {
+  const parts = DAY.exec(value);
+  if (!parts)
+    return;
+  return new Date(Number(parts[1]), Number(parts[2]) - 1, Number(parts[3]));
+}
+function valuesFor(params, values) {
+  const worded = { ...values };
+  for (const { name, kind } of params) {
+    const value = values[name];
+    if (typeof value !== "string")
+      continue;
+    if (kind === "DATE") {
+      const day = dayOf(value);
+      if (day)
+        worded[name] = day;
+    } else if ((kind === "NUMBER" || kind === "PLURAL") && value.trim() !== "" && !Number.isNaN(Number(value))) {
+      worded[name] = Number(value);
+    }
+  }
+  return worded;
+}
+
+// src/errors/messages.ts
+function createApiMessages({
+  format
+}) {
+  const catalogues = new Map;
+  const messageOf = (language, code) => catalogues.get(language)?.get(code);
+  function formatEntry(entry, values, language) {
+    const worded = valuesFor(entry.params, values ?? {});
+    let failed = false;
+    try {
+      const text = format(entry.message, language, worded, {
+        onError: () => {
+          failed = true;
+        }
+      });
+      return failed ? undefined : text;
+    } catch {
+      return;
+    }
+  }
+  return {
+    set(language, messages) {
+      catalogues.set(language, new Map(Object.entries(messages)));
+    },
+    add(language, messages) {
+      const held = catalogues.get(language) ?? new Map;
+      for (const [code, message] of Object.entries(messages)) {
+        held.set(code, message);
+      }
+      catalogues.set(language, held);
+    },
+    clear() {
+      catalogues.clear();
+    },
+    messageOf,
+    format: formatEntry,
+    apiMessage(code, values, language) {
+      const entry = messageOf(language, code);
+      return entry ? formatEntry(entry, values, language) : undefined;
+    }
+  };
+}
+// src/errors/provider.ts
+function ApiMessagesProvider({
+  messages,
+  value,
+  children
+}) {
+  const inBrowser = typeof globalThis.document !== "undefined";
+  if (value && inBrowser) {
+    for (const [language, held] of Object.entries(value)) {
+      messages.add(language, held);
+    }
+  }
+  return children;
+}
+// src/errors/use-json-fetcher.ts
+import { useFetcher } from "react-router";
+function useJsonFetcher(key, action) {
+  const fetcher = useFetcher(key ? { key } : undefined);
+  const post = (body, to = action) => fetcher.submit(body, {
+    method: "post",
+    encType: "application/json",
+    ...to ? { action: to } : {}
+  });
+  return { fetcher, post, busy: fetcher.state !== "idle" };
+}
+export {
+  ApiMessagesProvider,
+  REQUEST_ID_HEADER,
+  apiCallFailure,
+  apiCodeResolver,
+  createApiErrors,
+  createApiMessages,
+  createErrorCatalogue,
+  errorRequestId,
+  isApiErrorLike,
+  jsonActions,
+  nextOf,
+  operationName,
+  requestIdOf,
+  routeError,
+  useJsonFetcher,
+  waitMinutes
+};
+
+//# debugId=0AF5BB2424365EAA64756E2164756E21
+//# sourceMappingURL=index.js.map