@better-i18n/next 0.5.2 → 0.5.4

package/src/middleware.ts

@@ -1,243 +0,0 @@
-import createMiddleware from "next-intl/middleware";
-import { NextRequest, NextResponse } from "next/server";
-import { createI18nCore, createLogger, detectLocale } from "@better-i18n/core";
-import type { I18nMiddlewareConfig } from "@better-i18n/core";
-
-import { normalizeConfig } from "./config";
-import { getLocales } from "./server";
-import type { I18nConfig } from "./types";
-
-/**
- * Context passed to the middleware callback (Clerk-style pattern)
- */
-export interface MiddlewareContext {
-  /** Detected locale from the request */
-  locale: string;
-  /** The i18n response with headers already set - can be modified */
-  response: NextResponse;
-}
-
-/**
- * Callback function for Clerk-style middleware composition
- *
- * @param request - The incoming Next.js request
- * @param context - Contains locale and response from i18n middleware
- * @returns NextResponse to short-circuit (e.g., redirect), or void to continue with i18n response
- */
-export type MiddlewareCallback = (
-  request: NextRequest,
-  context: MiddlewareContext
-) => Promise<NextResponse | void> | NextResponse | void;
-
-/**
- * Legacy Next-intl based middleware
- */
-export const createI18nMiddleware = (config: I18nConfig) => {
-  const normalized = normalizeConfig(config);
-  const logger = createLogger(normalized, "middleware");
-
-  return async function middleware(request: NextRequest) {
-    const locales = await getLocales(normalized);
-    logger.debug("locales", locales);
-
-    const handleI18nRouting = createMiddleware({
-      locales,
-      defaultLocale: normalized.defaultLocale,
-      localePrefix: normalized.localePrefix,
-    });
-
-    return handleI18nRouting(request);
-  };
-};
-
-export const createI18nProxy = createI18nMiddleware;
-
-/**
- * Modern composable middleware for Better i18n (Clerk-style pattern)
- *
- * Delegates to next-intl's middleware internally to ensure full compatibility
- * with `getRequestConfig({ requestLocale })` while keeping our compose-friendly
- * API and custom locale detection options.
- *
- * @example Simple usage (no callback)
- * ```ts
- * export default createBetterI18nMiddleware({
- *   project: "acme/dashboard",
- *   defaultLocale: "en",
- *   localePrefix: "always",
- * });
- * ```
- *
- * @example With callback (Clerk-style - recommended for auth)
- * ```ts
- * export default createBetterI18nMiddleware({
- *   project: "acme/dashboard",
- *   defaultLocale: "en",
- *   localePrefix: "always",
- * }, async (request, { locale, response }) => {
- *   // Auth logic here - locale and response are available
- *   if (needsLogin) {
- *     return NextResponse.redirect(new URL(`/${locale}/login`, request.url));
- *   }
- *   // Return nothing = i18n response is used (headers preserved!)
- * });
- * ```
- */
-export function createBetterI18nMiddleware(
-  config: I18nMiddlewareConfig,
-  callback?: MiddlewareCallback
-) {
-  const { project, defaultLocale, localePrefix = "as-needed", detection = {} } = config;
-
-  const {
-    cookie = true,
-    browserLanguage = true,
-    cookieName = "locale",
-    cookieMaxAge = 31536000,
-  } = detection;
-
-  // Create i18n core instance for CDN operations
-  const i18nCore = createI18nCore({ project, defaultLocale });
-
-  // Cache for next-intl middleware instance (recreate only when locales change)
-  let cachedMiddleware: ReturnType<typeof createMiddleware> | null = null;
-  let cachedLocalesKey: string | null = null;
-
-  return async (request: NextRequest): Promise<NextResponse> => {
-    // 1. Fetch available locales from CDN
-    const availableLocales = await i18nCore.getLocales();
-
-    // 2. Our custom locale detection
-    // When localePrefix is "never", path has no locale segment — skip it
-    const pathLocale =
-      localePrefix === "never"
-        ? null
-        : request.nextUrl.pathname.split("/")[1];
-    const cookieLocale = cookie ? request.cookies.get(cookieName)?.value : null;
-    const headerLocale = browserLanguage
-      ? request.headers.get("accept-language")?.split(",")[0]?.split("-")[0]
-      : null;
-
-    const result = detectLocale({
-      project,
-      defaultLocale,
-      pathLocale,
-      cookieLocale: cookieLocale || null,
-      headerLocale,
-      availableLocales,
-    });
-
-    const detectedLocale = result.locale;
-
-    let response: NextResponse;
-
-    if (localePrefix === "never") {
-      // 3a. "never" mode: bypass next-intl middleware entirely.
-      // next-intl's createMiddleware tries URL rewriting which breaks cookie-only locale.
-      // We create a plain response and set the header that next-intl's getRequestConfig reads.
-      response = NextResponse.next();
-      response.headers.set(
-        "x-middleware-request-x-next-intl-locale",
-        detectedLocale
-      );
-    } else {
-      // 3b. URL-based modes: delegate to next-intl middleware as before
-      const localesKey = availableLocales.join(",");
-      if (!cachedMiddleware || cachedLocalesKey !== localesKey) {
-        cachedMiddleware = createMiddleware({
-          locales: availableLocales,
-          defaultLocale,
-          localePrefix,
-        });
-        cachedLocalesKey = localesKey;
-      }
-      response = cachedMiddleware(request);
-    }
-
-    // 4. Add x-locale header for backwards compatibility
-    response.headers.set("x-locale", detectedLocale);
-
-    // 5. Set our custom cookie if needed
-    if (cookie && result.shouldSetCookie) {
-      response.cookies.set(cookieName, detectedLocale, {
-        path: "/",
-        maxAge: cookieMaxAge,
-        sameSite: "lax",
-      });
-    }
-
-    // 6. If callback provided, execute it (Clerk-style)
-    if (callback) {
-      const callbackResult = await callback(request, {
-        locale: detectedLocale,
-        response,
-      });
-
-      // If callback returns a response (e.g., redirect), use it
-      if (callbackResult) {
-        return callbackResult;
-      }
-    }
-
-    // 7. Return the response
-    return response;
-  };
-}
-
-/**
- * Helper to compose multiple Next.js middleware
- *
- * @deprecated Use `createBetterI18nMiddleware` with a callback instead (Clerk-style pattern).
- * The callback approach is more reliable and gives you access to the detected locale.
- *
- * @example Migration
- * ```ts
- * // Before (deprecated):
- * export default composeMiddleware(i18nMiddleware, authMiddleware);
- *
- * // After (recommended):
- * export default createBetterI18nMiddleware(config, async (req, { locale, response }) => {
- *   // Auth logic here
- * });
- * ```
- *
- * @see https://github.com/better-i18n/better-i18n#middleware-composition
- */
-export function composeMiddleware(
-  ...middlewares: Array<(req: NextRequest) => Promise<NextResponse>>
-) {
-  if (process.env.NODE_ENV === "development") {
-    console.warn(
-      "[@better-i18n/next] composeMiddleware is deprecated. " +
-        "Use createBetterI18nMiddleware with a callback instead. " +
-        "See: https://github.com/better-i18n/better-i18n#middleware-composition"
-    );
-  }
-
-  return async (request: NextRequest): Promise<NextResponse> => {
-    const finalResponse = NextResponse.next();
-
-    for (const middleware of middlewares) {
-      const response = await middleware(request);
-
-      // Short-circuit on redirect/rewrite (status >= 300)
-      if (response.status >= 300) {
-        return response;
-      }
-
-      // Merge headers from this middleware into the final response
-      response.headers.forEach((value, key) => {
-        finalResponse.headers.set(key, value);
-      });
-
-      // Merge cookies from this middleware into the final response
-      response.cookies.getAll().forEach((cookie) => {
-        finalResponse.cookies.set(cookie.name, cookie.value, {
-          ...cookie,
-        });
-      });
-    }
-
-    return finalResponse;
-  };
-}

package/src/proxy.ts

@@ -1 +0,0 @@
-export { createI18nProxy } from "./middleware";

package/src/server.ts

@@ -1,164 +0,0 @@
-import { getRequestConfig } from "next-intl/server";
-import { cookies } from "next/headers";
-import { createI18nCore } from "@better-i18n/core";
-import type { I18nCore, Messages } from "@better-i18n/core";
-
-import { normalizeConfig, getProjectBaseUrl } from "./config";
-import type { I18nConfig, NextFetchRequestInit } from "./types";
-
-/**
- * Next.js i18n core instance with ISR support
- */
-export interface NextI18nCore extends I18nCore {
-  /**
-   * Get messages for a locale with Next.js ISR revalidation
-   */
-  getMessages: (locale: string) => Promise<Messages>;
-}
-
-/**
- * Create a fetch function with Next.js ISR revalidation
- */
-const createIsrFetch = (revalidateSeconds: number): typeof fetch => {
-  return (input: RequestInfo | URL, init?: RequestInit) => {
-    const nextInit: NextFetchRequestInit = {
-      ...init,
-      next: { revalidate: revalidateSeconds },
-    };
-    return fetch(input, nextInit);
-  };
-};
-
-/**
- * Create a Next.js i18n core instance with ISR support
- *
- * This wraps the framework-agnostic `createI18nCore` from `@better-i18n/core`
- * and adds Next.js-specific ISR revalidation for optimal caching.
- *
- * @example
- * ```ts
- * const i18n = createNextI18nCore({
- *   project: 'acme/dashboard',
- *   defaultLocale: 'en',
- * })
- *
- * // Manifest cached for 1 hour (ISR)
- * const locales = await i18n.getLocales()
- *
- * // Messages revalidated every 30s (ISR)
- * const messages = await i18n.getMessages('en')
- * ```
- */
-export const createNextI18nCore = (config: I18nConfig): NextI18nCore => {
-  const normalized = normalizeConfig(config);
-
-  // Core instance uses ISR fetch for manifest (default 3600s)
-  const manifestFetch = createIsrFetch(normalized.manifestRevalidateSeconds);
-  const i18nCore = createI18nCore({
-    project: normalized.project,
-    defaultLocale: normalized.defaultLocale,
-    cdnBaseUrl: normalized.cdnBaseUrl,
-    manifestCacheTtlMs: normalized.manifestCacheTtlMs,
-    debug: normalized.debug,
-    logLevel: normalized.logLevel,
-    fetch: manifestFetch,
-  });
-
-  // Messages use separate ISR fetch with shorter revalidation (default 30s)
-  const messagesFetch = createIsrFetch(normalized.messagesRevalidateSeconds);
-
-  return {
-    ...i18nCore,
-    getMessages: async (locale: string): Promise<Messages> => {
-      const url = `${getProjectBaseUrl(normalized)}/${locale}/translations.json`;
-      const response = await messagesFetch(url);
-      if (!response.ok) {
-        throw new Error(`[better-i18n] Messages fetch failed for locale "${locale}" (${response.status})`);
-      }
-      return response.json();
-    },
-  };
-};
-
-/**
- * Create next-intl request config for App Router
- *
- * @example
- * ```ts
- * // i18n/request.ts
- * import { createNextIntlRequestConfig } from '@better-i18n/next/server'
- *
- * export default createNextIntlRequestConfig({
- *   project: 'acme/dashboard',
- *   defaultLocale: 'en',
- * })
- * ```
- */
-export const createNextIntlRequestConfig = (config: I18nConfig) =>
-  getRequestConfig(async ({ requestLocale }) => {
-    const i18n = createNextI18nCore(config);
-    const normalized = normalizeConfig(config);
-    const locales = await i18n.getLocales();
-
-    // 1. Middleware header (set by next-intl or our middleware)
-    let locale = await requestLocale;
-
-    // 2. Cookie fallback — critical for localePrefix: "never" where
-    //    requestLocale may be undefined if middleware header isn't forwarded
-    if (!locale) {
-      try {
-        const cookieStore = await cookies();
-        const cookieLocale = cookieStore.get(normalized.cookieName)?.value;
-        if (cookieLocale && locales.includes(cookieLocale)) {
-          locale = cookieLocale;
-        }
-      } catch {
-        // cookies() throws in non-request contexts (e.g. build time)
-      }
-    }
-
-    // 3. Final fallback to defaultLocale
-    if (!locale || !locales.includes(locale)) {
-      locale = normalized.defaultLocale;
-    }
-
-    return {
-      locale,
-      messages: await i18n.getMessages(locale),
-    };
-  });
-
-// Convenience exports for backwards compatibility
-
-/**
- * Fetch manifest from CDN
- */
-export const fetchManifest = (config: I18nConfig) =>
-  createNextI18nCore(config).getManifest();
-
-/**
- * Get manifest with caching
- */
-export const getManifest = (config: I18nConfig, options?: { forceRefresh?: boolean }) =>
-  createNextI18nCore(config).getManifest(options);
-
-/**
- * Get available locale codes
- */
-export const getLocales = (config: I18nConfig) =>
-  createNextI18nCore(config).getLocales();
-
-/**
- * Get messages for a locale
- */
-export const getMessages = (config: I18nConfig, locale: string) =>
-  createNextI18nCore(config).getMessages(locale);
-
-/**
- * Get language options with metadata
- */
-export const getManifestLanguages = (config: I18nConfig) =>
-  createNextI18nCore(config).getLanguages();
-
-// Re-export types from core
-export type { LanguageOption, ManifestLanguage, ManifestResponse, Messages } from "@better-i18n/core";

package/src/types.ts

@@ -1,66 +0,0 @@
-// Re-export common types from i18n-core
-export type {
-  Locale,
-  LogLevel,
-  ManifestLanguage,
-  ManifestFile,
-  ManifestResponse,
-  LanguageOption,
-  Messages,
-  Logger,
-  ParsedProject,
-} from "@better-i18n/core";
-
-import type { I18nCoreConfig, NormalizedConfig as CoreNormalizedConfig } from "@better-i18n/core";
-
-// Next.js-specific types
-
-export type LocalePrefix = "as-needed" | "always" | "never";
-
-/**
- * Next.js i18n configuration (extends core config)
- */
-export interface I18nConfig extends I18nCoreConfig {
-  /**
-   * URL locale prefix behavior
-   * @default "as-needed"
-   */
-  localePrefix?: LocalePrefix;
-
-  /**
-   * Cookie name used for locale persistence when localePrefix is "never"
-   * @default "locale"
-   */
-  cookieName?: string;
-
-  /**
-   * Next.js ISR revalidation time for manifest (seconds)
-   * @default 3600
-   */
-  manifestRevalidateSeconds?: number;
-
-  /**
-   * Next.js ISR revalidation time for messages (seconds)
-   * @default 30
-   */
-  messagesRevalidateSeconds?: number;
-}
-
-/**
- * Normalized Next.js config with defaults
- */
-export interface NormalizedConfig extends CoreNormalizedConfig, Omit<I18nConfig, keyof I18nCoreConfig> {
-  localePrefix: LocalePrefix;
-  cookieName: string;
-  manifestRevalidateSeconds: number;
-  messagesRevalidateSeconds: number;
-}
-
-/**
- * Next.js fetch request init with ISR options
- */
-export type NextFetchRequestInit = RequestInit & {
-  next?: {
-    revalidate?: number;
-  };
-};