intor 2.2.4 → 2.2.6

package/dist/server/index.js

@@ -0,0 +1,682 @@
+import path from 'path';
+import { performance as performance$1 } from 'perf_hooks';
+import pLimit from 'p-limit';
+import fs from 'fs/promises';
+import { logry } from 'logry';
+import merge from 'lodash.merge';
+import Keyv from 'keyv';
+import { Translator } from 'intor-translator';
+
+// src/server/intor/utils/should-load-messages.ts
+var shouldLoadMessages = (loader) => {
+  if (!loader) return false;
+  const { type, lazyLoad } = loader;
+  if (type === "local") return true;
+  if (lazyLoad) return false;
+  return true;
+};
+
+// src/config/constants/cache.constants.ts
+var DEFAULT_CACHE_OPTIONS = {
+  enabled: process.env.NODE_ENV === "production",
+  ttl: 60 * 60 * 1e3
+  // 1 hour
+};
+
+// src/server/shared/logger/global-logger-pool.ts
+function getGlobalLoggerPool() {
+  if (!globalThis.__INTOR_LOGGER_POOL__) {
+    globalThis.__INTOR_LOGGER_POOL__ = /* @__PURE__ */ new Map();
+  }
+  return globalThis.__INTOR_LOGGER_POOL__;
+}
+function clearLoggerPool() {
+  const pool = getGlobalLoggerPool();
+  pool.clear();
+}
+
+// src/server/shared/logger/get-logger.ts
+var DEFAULT_FORMATTER_CONFIG = {
+  node: { meta: { compact: true }, lineBreaksAfter: 1 }
+};
+function getLogger({
+  id = "default",
+  formatterConfig,
+  preset,
+  ...options
+}) {
+  const pool = getGlobalLoggerPool();
+  let logger = pool.get(id);
+  const useDefault = !formatterConfig && !preset;
+  if (!logger) {
+    logger = logry({
+      id,
+      formatterConfig: useDefault ? DEFAULT_FORMATTER_CONFIG : formatterConfig,
+      preset,
+      ...options
+    });
+    pool.set(id, logger);
+    if (pool.size > 1e3) {
+      const keys = [...pool.keys()];
+      for (const key of keys.slice(0, 200)) pool.delete(key);
+    }
+  }
+  return logger;
+}
+
+// src/server/messages/load-local-messages/read-locale-messages/collect-file-entries/collect-file-entries.ts
+async function collectFileEntries({
+  readdir = fs.readdir,
+  limit,
+  rootDir,
+  namespaces,
+  extraOptions: { exts = [".json"], loggerOptions } = {}
+}) {
+  const baseLogger = getLogger({ ...loggerOptions });
+  const logger = baseLogger.child({ scope: "collect-file-entries" });
+  const results = [];
+  const walk = async (currentDir) => {
+    let entries = [];
+    try {
+      entries = await readdir(currentDir, { withFileTypes: true });
+    } catch (error) {
+      logger.error(`Error reading directory: ${currentDir}`, { error });
+      return;
+    }
+    const tasks = entries.map(
+      (entry) => limit(async () => {
+        const fullPath = path.join(currentDir, entry.name);
+        if (entry.isDirectory()) {
+          await walk(fullPath);
+          return;
+        }
+        if (!exts.some((ext2) => entry.name.endsWith(ext2))) return;
+        const relativePath = path.relative(rootDir, fullPath);
+        const ext = path.extname(relativePath);
+        const withoutExt = relativePath.slice(0, -ext.length);
+        const segments = withoutExt.split(path.sep).filter(Boolean);
+        const namespace = segments.at(0);
+        if (!namespace) return;
+        if (namespaces && namespace !== "index") {
+          if (!namespaces.includes(namespace)) return;
+        }
+        results.push({
+          namespace,
+          fullPath,
+          relativePath,
+          segments,
+          basename: path.basename(entry.name, ext)
+        });
+      })
+    );
+    await Promise.all(tasks);
+  };
+  await walk(rootDir);
+  if (logger.core.level === "debug") {
+    logger.debug("Local message files collected.", {
+      count: results.length
+    });
+  }
+  logger.trace("Local message files collected.", {
+    count: results.length,
+    fileEntries: results.map(({ namespace, relativePath }) => ({
+      namespace: namespace === "index" ? null : namespace,
+      relativePath
+    }))
+  });
+  return results;
+}
+
+// src/server/messages/shared/utils/is-valid-messages.ts
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isValidMessages(value) {
+  if (!isPlainObject(value)) return false;
+  const stack = [value];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    for (const v of Object.values(current)) {
+      if (typeof v === "string") continue;
+      if (isPlainObject(v)) {
+        stack.push(v);
+      } else {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+async function jsonReader(filePath, readFile = fs.readFile) {
+  const raw = await readFile(filePath, "utf8");
+  const parsed = JSON.parse(raw);
+  return parsed;
+}
+
+// src/server/messages/load-local-messages/read-locale-messages/parse-file-entries/utils/nest-object-from-path.ts
+function nestObjectFromPath(path5, value) {
+  let obj = value;
+  for (let i = path5.length - 1; i >= 0; i--) {
+    obj = { [path5[i]]: obj };
+  }
+  return obj;
+}
+
+// src/server/messages/load-local-messages/read-locale-messages/parse-file-entries/parse-file-entries.ts
+async function parseFileEntries({
+  fileEntries,
+  limit,
+  extraOptions: { messagesReader, loggerOptions } = {}
+}) {
+  const baseLogger = getLogger({ ...loggerOptions });
+  const logger = baseLogger.child({ scope: "parse-file-entries" });
+  const parsedFileEntries = [];
+  const tasks = fileEntries.map(
+    ({ namespace, segments, basename, fullPath }) => limit(async () => {
+      try {
+        const segsWithoutNs = segments.slice(1);
+        const ext = path.extname(fullPath);
+        const json = ext !== ".json" && messagesReader ? await messagesReader(fullPath) : await jsonReader(fullPath);
+        if (!isValidMessages(json)) {
+          throw new Error(
+            "JSON file does not match NamespaceMessages structure"
+          );
+        }
+        const isIndex = basename === "index";
+        const keyPath = isIndex ? segsWithoutNs.slice(0, -1) : segsWithoutNs;
+        const nested = nestObjectFromPath(keyPath, json);
+        parsedFileEntries.push({ namespace, messages: nested });
+        logger.trace("Parsed file.", { path: fullPath });
+      } catch (error) {
+        logger.error("Failed to read or parse file.", {
+          path: fullPath,
+          error
+        });
+      }
+    })
+  );
+  await Promise.all(tasks);
+  const result = {};
+  for (const { namespace, messages } of parsedFileEntries) {
+    if (namespace === "index") {
+      merge(result, messages);
+    } else {
+      result[namespace] = merge(
+        result[namespace] ?? {},
+        messages
+      );
+    }
+  }
+  return result;
+}
+
+// src/server/messages/load-local-messages/read-locale-messages/read-locale-messages.ts
+var readLocaleMessages = async ({
+  limit,
+  rootDir = "messages",
+  locale,
+  namespaces,
+  extraOptions: { exts, messagesReader, loggerOptions } = {}
+}) => {
+  const fileEntries = await collectFileEntries({
+    rootDir: path.resolve(process.cwd(), rootDir, locale),
+    namespaces,
+    limit,
+    extraOptions: { exts, loggerOptions }
+  });
+  const namespaceMessages = await parseFileEntries({
+    fileEntries,
+    limit,
+    extraOptions: { messagesReader, loggerOptions }
+  });
+  const localeMessages = { [locale]: namespaceMessages };
+  return localeMessages;
+};
+function getGlobalMessagesPool() {
+  if (!globalThis.__INTOR_MESSAGES_POOL__) {
+    globalThis.__INTOR_MESSAGES_POOL__ = new Keyv();
+  }
+  return globalThis.__INTOR_MESSAGES_POOL__;
+}
+function clearMessagesPool() {
+  const pool = getGlobalMessagesPool();
+  pool.clear();
+}
+var mergeMessages = (staticMessages = {}, loadedMessages = {}) => {
+  if (!loadedMessages) return { ...staticMessages };
+  return merge({}, staticMessages, loadedMessages);
+};
+
+// src/shared/utils/normalize-cache-key.ts
+var CACHE_KEY_DELIMITER = "|";
+var sanitize = (k) => k.replaceAll(/[\u200B-\u200D\uFEFF]/g, "").replaceAll(/[\r\n]/g, "").trim();
+var normalizeCacheKey = (key, delimiter = CACHE_KEY_DELIMITER) => {
+  if (key === null || key === void 0) return null;
+  if (Array.isArray(key)) {
+    if (key.length === 0) return null;
+    const normalized = key.map((k) => {
+      if (k === null) return "__null";
+      if (k === void 0) return "__undefined";
+      if (typeof k === "boolean") return k ? "__true" : "__false";
+      return sanitize(String(k));
+    });
+    return normalized.join(delimiter);
+  }
+  if (typeof key === "boolean") return key ? "__true" : "__false";
+  return String(key);
+};
+
+// src/shared/constants/prefix-placeholder.ts
+var PREFIX_PLACEHOLDER = "{locale}";
+
+// src/shared/utils/resolve-namespaces.ts
+var resolveNamespaces = ({
+  config,
+  pathname
+}) => {
+  const { loader } = config;
+  const { routeNamespaces = {}, namespaces } = loader || {};
+  if (Object.keys(routeNamespaces).length === 0 && !namespaces)
+    return void 0;
+  const standardizedPathname = standardizePathname({ config, pathname });
+  const placeholderRemovedPathname = standardizedPathname.replace(
+    `/${PREFIX_PLACEHOLDER}`,
+    ""
+  );
+  const collected = [
+    ...routeNamespaces.default || [],
+    // default
+    ...namespaces || [],
+    // default
+    ...routeNamespaces[standardizedPathname] || [],
+    // exact match
+    ...routeNamespaces[placeholderRemovedPathname] || []
+    // exact match
+  ];
+  const prefixPatterns = Object.keys(routeNamespaces).filter(
+    (pattern) => pattern.endsWith("/*")
+  );
+  for (const pattern of prefixPatterns) {
+    const basePath = pattern.replace(/\/\*$/, "");
+    if (standardizedPathname.startsWith(basePath) || placeholderRemovedPathname.startsWith(basePath)) {
+      collected.push(...routeNamespaces[pattern] || []);
+    }
+  }
+  return [...new Set(collected)];
+};
+
+// src/shared/utils/pathname/normalize-pathname.ts
+var normalizePathname = (rawPathname, options = {}) => {
+  const length = rawPathname.length;
+  let start = 0;
+  let end = length - 1;
+  while (start <= end && (rawPathname.codePointAt(start) ?? 0) <= 32) start++;
+  while (end >= start && (rawPathname.codePointAt(end) ?? 0) <= 32) end--;
+  if (start > end) return "/";
+  let result = "";
+  let hasSlash = false;
+  for (let i = start; i <= end; i++) {
+    const char = rawPathname[i];
+    if (char === "/") {
+      if (!hasSlash) {
+        hasSlash = true;
+      }
+    } else {
+      result += hasSlash || result === "" ? "/" + char : char;
+      hasSlash = false;
+    }
+  }
+  if (options.removeLeadingSlash && result.startsWith("/")) {
+    result = result.slice(1);
+  }
+  return result || "/";
+};
+
+// src/shared/utils/pathname/standardize-pathname.ts
+var standardizePathname = ({
+  config,
+  pathname
+}) => {
+  const { routing } = config;
+  const { basePath } = routing;
+  const parts = [
+    normalizePathname(basePath),
+    PREFIX_PLACEHOLDER,
+    normalizePathname(pathname)
+  ];
+  const standardizedPathname = parts.join("/").replaceAll(/\/{2,}/g, "/");
+  return normalizePathname(standardizedPathname);
+};
+
+// src/server/messages/load-local-messages/load-local-messages.ts
+var loadLocalMessages = async ({
+  pool = getGlobalMessagesPool(),
+  rootDir = "messages",
+  locale,
+  fallbackLocales,
+  namespaces,
+  extraOptions: {
+    concurrency = 10,
+    cacheOptions = DEFAULT_CACHE_OPTIONS,
+    loggerOptions = { id: "default" },
+    exts,
+    messagesReader
+  } = {},
+  allowCacheWrite = false
+}) => {
+  const baseLogger = getLogger({ ...loggerOptions });
+  const logger = baseLogger.child({ scope: "load-local-messages" });
+  const start = performance$1.now();
+  logger.debug("Loading local messages from directory.", {
+    rootDir,
+    resolvedRootDir: path.resolve(process.cwd(), rootDir)
+  });
+  const key = normalizeCacheKey([
+    loggerOptions.id,
+    "loaderType:local",
+    rootDir,
+    locale,
+    (fallbackLocales || []).toSorted().join(","),
+    (namespaces || []).toSorted().join(",")
+  ]);
+  if (cacheOptions.enabled && key) {
+    const cached = await pool?.get(key);
+    if (cached) {
+      logger.debug("Messages cache hit.", { key });
+      return cached;
+    }
+  }
+  const limit = pLimit(concurrency);
+  const candidateLocales = [locale, ...fallbackLocales || []];
+  let messages;
+  for (const candidateLocale of candidateLocales) {
+    try {
+      const result = await readLocaleMessages({
+        limit,
+        rootDir,
+        locale: candidateLocale,
+        namespaces,
+        extraOptions: { loggerOptions, exts, messagesReader }
+      });
+      if (result && Object.values(result[candidateLocale] || {}).length > 0) {
+        messages = result;
+        break;
+      }
+    } catch (error) {
+      logger.error("Failed to read locale messages", {
+        locale: candidateLocale,
+        error
+      });
+    }
+  }
+  if (allowCacheWrite && cacheOptions.enabled && key && messages) {
+    await pool?.set(key, messages, cacheOptions.ttl);
+  }
+  const end = performance$1.now();
+  const duration = Math.round(end - start);
+  logger.trace("Finished loading local messages.", {
+    loadedLocale: messages ? Object.keys(messages)[0] : void 0,
+    duration: `${duration} ms`
+  });
+  return messages;
+};
+
+// src/server/messages/load-remote-messages/fetch-locale-messages/fetch-locale-messages.ts
+var fetchLocaleMessages = async ({
+  remoteUrl,
+  remoteHeaders,
+  searchParams,
+  locale,
+  extraOptions: { loggerOptions } = {}
+}) => {
+  const baseLogger = getLogger({ ...loggerOptions });
+  const logger = baseLogger.child({ scope: "fetch-locale-messages" });
+  try {
+    const params = new URLSearchParams(searchParams);
+    params.append("locale", locale);
+    const url = `${remoteUrl}?${params.toString()}`;
+    const headers = {
+      "Content-Type": "application/json",
+      ...remoteHeaders
+    };
+    const response = await fetch(url, {
+      method: "GET",
+      headers,
+      cache: "no-store"
+    });
+    if (!response.ok) {
+      throw new Error(`HTTP error ${response.status} ${response.statusText}`);
+    }
+    const data = await response.json();
+    if (!isValidMessages(data[locale])) {
+      throw new Error("JSON file does not match NamespaceMessages structure");
+    }
+    return data;
+  } catch (error) {
+    logger.warn("Fetching locale messages failed.", {
+      locale,
+      remoteUrl,
+      searchParams: decodeURIComponent(searchParams.toString()),
+      error
+    });
+    return;
+  }
+};
+
+// src/server/messages/load-remote-messages/fetch-locale-messages/utils/build-search-params.ts
+var buildSearchParams = (params) => {
+  const searchParams = new URLSearchParams();
+  const appendParam = (key, value) => {
+    if (value === void 0 || value === null) return;
+    if (Array.isArray(value) && value.length === 0) return;
+    if (Array.isArray(value)) {
+      value.forEach((v) => v && searchParams.append(key, v));
+    } else {
+      searchParams.append(key, value);
+    }
+  };
+  Object.entries(params).forEach(([key, value]) => {
+    appendParam(key, value);
+  });
+  return searchParams;
+};
+
+// src/server/messages/load-remote-messages/load-remote-messages.ts
+var loadRemoteMessages = async ({
+  pool = getGlobalMessagesPool(),
+  rootDir,
+  remoteUrl,
+  remoteHeaders,
+  locale,
+  fallbackLocales = [],
+  namespaces = [],
+  extraOptions: {
+    cacheOptions = DEFAULT_CACHE_OPTIONS,
+    loggerOptions = { id: "default" }
+  } = {},
+  allowCacheWrite
+}) => {
+  const baseLogger = getLogger({ ...loggerOptions });
+  const logger = baseLogger.child({ scope: "load-remote-messages" });
+  const start = performance.now();
+  logger.debug("Loading remote messages from api.", { remoteUrl });
+  const key = normalizeCacheKey([
+    loggerOptions.id,
+    "loaderType:remote",
+    rootDir,
+    locale,
+    (fallbackLocales ?? []).toSorted().join(","),
+    (namespaces ?? []).toSorted().join(",")
+  ]);
+  if (cacheOptions.enabled && key) {
+    const cached = await pool?.get(key);
+    if (cached) {
+      logger.debug("Messages cache hit.", { key });
+      return cached;
+    }
+  }
+  const searchParams = buildSearchParams({ rootDir, namespaces });
+  const candidateLocales = [locale, ...fallbackLocales || []];
+  let messages;
+  for (const candidateLocale of candidateLocales) {
+    try {
+      const result = await fetchLocaleMessages({
+        remoteUrl,
+        remoteHeaders,
+        searchParams,
+        locale: candidateLocale,
+        extraOptions: { loggerOptions }
+      });
+      if (result && Object.values(result[candidateLocale] || {}).length > 0) {
+        messages = result;
+        break;
+      }
+    } catch (error) {
+      logger.error("Failed to fetch locale messages.", {
+        locale: candidateLocale,
+        error
+      });
+    }
+  }
+  if (allowCacheWrite && cacheOptions.enabled && key && messages) {
+    await pool?.set(key, messages, cacheOptions.ttl);
+  }
+  const end = performance.now();
+  const duration = Math.round(end - start);
+  logger.trace("Finished loading remote messages.", {
+    loadedLocale: messages ? Object.keys(messages)[0] : void 0,
+    duration: `${duration} ms`
+  });
+  return messages;
+};
+
+// src/server/messages/load-messages.ts
+var loadMessages = async ({
+  config,
+  locale,
+  pathname = "",
+  extraOptions: { exts, messagesReader } = {},
+  allowCacheWrite = false
+}) => {
+  const baseLogger = getLogger({ id: config.id, ...config.logger });
+  const logger = baseLogger.child({ scope: "load-messages" });
+  if (!config.loader) {
+    logger.warn(
+      "No loader options have been configured in the current config."
+    );
+    return;
+  }
+  const { type, concurrency, rootDir } = config.loader;
+  const fallbackLocales = config.fallbackLocales[locale] || [];
+  const namespaces = resolveNamespaces({ config, pathname });
+  if (logger.core.level === "debug") {
+    logger.debug("Starting to load messages.", { locale });
+  }
+  logger.trace("Starting to load messages with runtime context.", {
+    loaderType: type,
+    locale,
+    fallbackLocales,
+    namespaces: namespaces && namespaces.length > 0 ? [...namespaces] : "[ALL]",
+    cache: config.cache,
+    concurrency: concurrency ?? 10
+  });
+  let loadedMessages;
+  if (type === "local") {
+    loadedMessages = await loadLocalMessages({
+      rootDir,
+      locale,
+      fallbackLocales,
+      namespaces,
+      extraOptions: {
+        concurrency,
+        cacheOptions: config.cache,
+        loggerOptions: { id: config.id, ...config.logger },
+        exts,
+        messagesReader
+      },
+      allowCacheWrite
+    });
+  } else if (type === "remote") {
+    loadedMessages = await loadRemoteMessages({
+      rootDir,
+      remoteUrl: config.loader.remoteUrl,
+      remoteHeaders: config.loader.remoteHeaders,
+      locale,
+      fallbackLocales,
+      namespaces,
+      extraOptions: {
+        cacheOptions: config.cache,
+        loggerOptions: { id: config.id, ...config.logger }
+      }
+    });
+  }
+  if (!loadedMessages || Object.keys(loadedMessages).length === 0) {
+    logger.warn("No messages found.", { locale, namespaces });
+  }
+  return loadedMessages;
+};
+
+// src/server/intor/intor.ts
+var intor = async (config, i18nContext, loadMessagesOptions = {}) => {
+  const baseLogger = getLogger({ id: config.id, ...config.logger });
+  const logger = baseLogger.child({ scope: "intor" });
+  logger.info("Start Intor initialization.");
+  const { messages, loader } = config;
+  const isI18nContextFunction = typeof i18nContext === "function";
+  const context = isI18nContextFunction ? await i18nContext(config) : {
+    locale: i18nContext?.locale || config.defaultLocale,
+    pathname: i18nContext?.pathname || ""
+  };
+  const { locale, pathname } = context;
+  const source = isI18nContextFunction ? i18nContext.name : "static fallback";
+  logger.debug(`I18n context resolved via ${source}.`, context);
+  let loadedMessages;
+  if (shouldLoadMessages(loader)) {
+    loadedMessages = await loadMessages({
+      config,
+      locale,
+      pathname,
+      extraOptions: {
+        exts: loadMessagesOptions.exts,
+        messagesReader: loadMessagesOptions.messagesReader
+      },
+      allowCacheWrite: true
+    });
+  }
+  const mergedMessages = mergeMessages(messages, loadedMessages);
+  logger.info("Messages successfully initialized.", {
+    static: { enabled: !!messages },
+    loaded: {
+      enabled: !!loadedMessages,
+      ...loader ? { loaderType: loader.type, lazyLoad: !!loader.lazyLoad } : null
+    },
+    merged: mergedMessages
+  });
+  return {
+    config,
+    initialLocale: locale,
+    pathname,
+    messages: mergedMessages
+  };
+};
+async function getTranslator(opts) {
+  const { config, locale, pathname = "", preKey, handlers } = opts;
+  const messages = await loadMessages({ config, locale, pathname });
+  const translator = new Translator({
+    locale,
+    messages,
+    fallbackLocales: config.fallbackLocales,
+    loadingMessage: config.translator?.loadingMessage,
+    placeholder: config.translator?.placeholder,
+    handlers
+  });
+  const props = { messages, locale };
+  const scoped = translator.scoped(preKey);
+  return {
+    ...props,
+    hasKey: preKey ? scoped.hasKey : translator.hasKey,
+    t: preKey ? scoped.t : translator.t
+  };
+}
+
+export { clearLoggerPool, clearMessagesPool, getTranslator, intor, loadLocalMessages, loadMessages, loadRemoteMessages };