1
import { PassThrough } from "node:stream";
2

3
import {
4
  createReadableStreamFromReadable,
5
  type EntryContext,
6
} from "@remix-run/node";
7
import { RemixServer } from "@remix-run/react";
8
import { createInstance } from "i18next";
9
import { isbot } from "isbot";
10
import { renderToPipeableStream } from "react-dom/server";
11
import { I18nextProvider, initReactI18next } from "react-i18next";
12

13
import { cookiesKey } from "./constants/cookies";
14
import { E_Language } from "./constants/languages";
15
import { getCookieValue } from "./data/cookies.server";
16
import i18n from "./i18n";
17
import i18next from "./i18next.server";
18

19
const ABORT_DELAY = 5000;
20

21
const checkFileExists = async (url: string): Promise<boolean> => {
22
  try {
23
    const response = await fetch(url, { method: "HEAD" });
24
    return response.ok;
25
  } catch (error) {
26
    console.error(`Error checking file existence at ${url}:`, error);
27
    return false;
28
  }
29
};
30

31
// eslint-disable-next-line @typescript-eslint/no-explicit-any
32
const fetchFile = async (url: string): Promise<any> => {
33
  try {
34
    const response = await fetch(url);
35
    if (!response.ok) {
36
      throw new Error(`Failed to load ${url}: ${response.statusText}`);
37
    }
38
    return await response.json();
39
  } catch (error) {
40
    throw new Error(`Error fetching ${url}: ${error}`);
41
  }
42
};
43

44
export default async function handleRequest(
45
  request: Request,
46
  responseStatusCode: number,
47
  responseHeaders: Headers,
48
  remixContext: EntryContext,
49
) {
50
  const callbackName = isbot(request.headers.get("user-agent"))
51
    ? "onAllReady"
52
    : "onShellReady";
53

54
  const instance = createInstance();
55
  const ns = i18next.getRouteNamespaces(remixContext);
56

57
  const CustomBackend = {
58
    read: (language: string, namespace: string, callback: Function) => {
59
      const protocol = request.headers.get("x-forwarded-proto") || "http";
60
      const host = request.headers.get("host");
61
      const baseUrl =
62
        process.env.NODE_ENV === "development"
63
          ? "https://your-url-prd.com"
64
          : `${protocol}://${host}`;
65

66
      const url = `${baseUrl}/locales/${language}/${namespace}.json`;
67

68
      const handleRequest = async () => {
69
        try {
70
          const exists = await checkFileExists(url);
71
          if (!exists) {
72
            callback(new Error(`File not found: ${url}`), false);
73
            return;
74
          }
75

76
          const data = await fetchFile(url);
77
          callback(null, data);
78
        } catch (error) {
79
          console.error(error);
80
          callback(error, false);
81
        }
82
      };
83

84
      handleRequest();
85
    },
86

87
    type: "backend",
88
  };
89

90
  await instance
91
    .use(initReactI18next)
92
    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
93
    // @ts-ignore
94
    .use(CustomBackend)
95
    .use(LanguageDetector)
96
    .init({
97
      ...i18n,
98
      ns,
99
    });
100

101
  return new Promise((resolve, reject) => {
102
    let didError = false;
103

104
    const { abort, pipe } = renderToPipeableStream(
105
      <I18nextProvider i18n={instance}>
106
        <RemixServer context={remixContext} url={request.url} />
107
      </I18nextProvider>,
108
      {
109
        [callbackName]: () => {
110
          const body = new PassThrough();
111
          const stream = createReadableStreamFromReadable(body);
112
          responseHeaders.set("Content-Type", "text/html");
113

114
          resolve(
115
            new Response(stream, {
116
              headers: responseHeaders,
117
              status: didError ? 500 : responseStatusCode,
118
            }),
119
          );
120

121
          pipe(body);
122
        },
123
        onError(error: unknown) {
124
          didError = true;
125

126
          console.error(error);
127
        },
128
        onShellError(error: unknown) {
129
          reject(error);
130
        },
131
      },
132
    );
133

134
    setTimeout(abort, ABORT_DELAY);
135
  });
136
}