@okam/directus-next 1.2.1 → 1.2.3

package/CHANGELOG.md

@@ -1,3 +1,25 @@
+## 1.2.3 (2025-07-24)
+
+### 🧱 Updated Dependencies
+
+- Updated core-lib to 1.17.0
+- Updated directus-node to 0.6.2
+- Updated directus-query to 1.4.2
+
+## 1.2.2 (2025-07-23)
+
+### 🩹 Fixes
+
+- issue with vite config for directus next ([#318](https://github.com/OKAMca/stack/pull/318))
+
+### 🧱 Updated Dependencies
+
+- Updated directus-node to 0.6.1
+
+### ❤️ Thank You
+
+- Marie-Maxime Tanguay @marie-maxime
+
 ## 1.2.1 (2025-07-22)
 
 ### 🩹 Fixes

package/{directus-next/src/lib/directusRouteRouter.mjs → directusRouteRouter-Bt3bEq4S.mjs}

@@ -1,6 +1,90 @@
 import { NextResponse } from "next/server";
-import { log } from "../logger.mjs";
-import { handleRedirect } from "../redirect/utils/handleRedirect.mjs";
+import { createLogger } from "@okam/logger";
+import { normalizePath } from "@okam/core-lib";
+import { capitalize } from "radashi";
+const logger = createLogger("[DirectusNext]");
+function log(msg, context, severity = "log") {
+  if (process.env.NODE_ENV === "development") {
+    logger.log(msg, severity, { context });
+  }
+}
+const defaultInternalUrl = "http://localhost:3000";
+function getRedirectSecretDefault() {
+  return process.env.NEXT_API_REDIRECT_SECRET || "";
+}
+function getVercelUrl() {
+  const url = process.env.VERCEL_URL;
+  if (!url) return null;
+  return `https://${url}`;
+}
+function getApiRouteUrlDefault() {
+  const url = process.env.NEXT_MIDDLEWARE_REDIRECT_URL ?? getVercelUrl() ?? defaultInternalUrl;
+  if (URL.canParse(url)) return url;
+  log(`Invalid URL ${url}. Falling back to default`, { url }, "warn");
+  return defaultInternalUrl;
+}
+const defaultApiRoute = "/api/redirect";
+async function getRedirectsRoute({
+  apiRoute = defaultApiRoute,
+  getApiRouteUrl = getApiRouteUrlDefault,
+  getRedirectSecret = getRedirectSecretDefault
+} = {}) {
+  const secret = getRedirectSecret();
+  try {
+    const url = new URL(apiRoute, getApiRouteUrl());
+    url.searchParams.set("secret", encodeURIComponent(secret));
+    const response = await fetch(url);
+    if (!response.ok) {
+      log(`${apiRoute} not ok. Returned`, { status: response.status }, "error");
+      return { redirects: [], rewrites: [] };
+    }
+    const data = await response.json();
+    return data;
+  } catch (error) {
+    log(`Error fetching redirects from ${apiRoute}.`, { error }, "error");
+    return { redirects: [], rewrites: [] };
+  }
+}
+function splitDestination(destination) {
+  const [pathname, search] = destination.split("?");
+  if (!search) {
+    return [pathname];
+  }
+  return [pathname, `?${search}`];
+}
+function validateExternalRedirect(redirect) {
+  if (!URL.canParse(redirect.destination)) {
+    return null;
+  }
+  return redirect.destination;
+}
+async function handleRedirect(request, options = {}) {
+  const url = request.nextUrl.clone();
+  const { pathname } = request.nextUrl;
+  const normalizedPathname = normalizePath(pathname);
+  const { redirects, rewrites } = await getRedirectsRoute(options);
+  const redirect = redirects.find(({ source }) => source === normalizedPathname);
+  const rewrite = rewrites.find(({ source }) => source === normalizedPathname);
+  const type = redirect ? "redirect" : "rewrite";
+  const reroute = redirect ?? rewrite;
+  if (!reroute) {
+    return null;
+  }
+  const { permanent } = reroute;
+  const status = permanent ? 308 : 307;
+  const externalRedirect = validateExternalRedirect(reroute);
+  if (externalRedirect) {
+    log(`External ${type} found`, { [type]: externalRedirect, permanent });
+    return NextResponse.redirect(externalRedirect, { status });
+  }
+  log(`${capitalize(type)} found`, { [type]: reroute, permanent });
+  const { destination } = reroute;
+  const [destinationPathname, search] = splitDestination(destination);
+  if (search) url.search = search;
+  url.pathname = destinationPathname;
+  log(`${capitalize(type)}ing to ${url.toString()} with status ${status}`);
+  return NextResponse[type](url, { status });
+}
 async function fetchPageSettingsTranslation(path) {
   const graphqlEndpoint = process.env.NEXT_SERVER_GRAPHQL_URL || process.env.NEXT_PUBLIC_GRAPHQL_URL;
   const graphqlApiKey = process.env.NEXT_PUBLIC_API_TOKEN;
@@ -98,5 +182,11 @@ async function directusRouteRouter(request, config, NextResponse$1 = NextRespons
   return NextResponse$1.rewrite(url);
 }
 export {
-  directusRouteRouter
+  getRedirectsRoute as a,
+  getApiRouteUrlDefault as b,
+  log as c,
+  directusRouteRouter as d,
+  getRedirectSecretDefault as g,
+  handleRedirect as h,
+  logger as l
 };

package/directusRouteRouter-CfK0xrh0.js

@@ -0,0 +1,191 @@
+"use strict";
+const server = require("next/server");
+const logger$1 = require("@okam/logger");
+const coreLib = require("@okam/core-lib");
+const radashi = require("radashi");
+const logger = logger$1.createLogger("[DirectusNext]");
+function log(msg, context, severity = "log") {
+  if (process.env.NODE_ENV === "development") {
+    logger.log(msg, severity, { context });
+  }
+}
+const defaultInternalUrl = "http://localhost:3000";
+function getRedirectSecretDefault() {
+  return process.env.NEXT_API_REDIRECT_SECRET || "";
+}
+function getVercelUrl() {
+  const url = process.env.VERCEL_URL;
+  if (!url) return null;
+  return `https://${url}`;
+}
+function getApiRouteUrlDefault() {
+  const url = process.env.NEXT_MIDDLEWARE_REDIRECT_URL ?? getVercelUrl() ?? defaultInternalUrl;
+  if (URL.canParse(url)) return url;
+  log(`Invalid URL ${url}. Falling back to default`, { url }, "warn");
+  return defaultInternalUrl;
+}
+const defaultApiRoute = "/api/redirect";
+async function getRedirectsRoute({
+  apiRoute = defaultApiRoute,
+  getApiRouteUrl = getApiRouteUrlDefault,
+  getRedirectSecret = getRedirectSecretDefault
+} = {}) {
+  const secret = getRedirectSecret();
+  try {
+    const url = new URL(apiRoute, getApiRouteUrl());
+    url.searchParams.set("secret", encodeURIComponent(secret));
+    const response = await fetch(url);
+    if (!response.ok) {
+      log(`${apiRoute} not ok. Returned`, { status: response.status }, "error");
+      return { redirects: [], rewrites: [] };
+    }
+    const data = await response.json();
+    return data;
+  } catch (error) {
+    log(`Error fetching redirects from ${apiRoute}.`, { error }, "error");
+    return { redirects: [], rewrites: [] };
+  }
+}
+function splitDestination(destination) {
+  const [pathname, search] = destination.split("?");
+  if (!search) {
+    return [pathname];
+  }
+  return [pathname, `?${search}`];
+}
+function validateExternalRedirect(redirect) {
+  if (!URL.canParse(redirect.destination)) {
+    return null;
+  }
+  return redirect.destination;
+}
+async function handleRedirect(request, options = {}) {
+  const url = request.nextUrl.clone();
+  const { pathname } = request.nextUrl;
+  const normalizedPathname = coreLib.normalizePath(pathname);
+  const { redirects, rewrites } = await getRedirectsRoute(options);
+  const redirect = redirects.find(({ source }) => source === normalizedPathname);
+  const rewrite = rewrites.find(({ source }) => source === normalizedPathname);
+  const type = redirect ? "redirect" : "rewrite";
+  const reroute = redirect ?? rewrite;
+  if (!reroute) {
+    return null;
+  }
+  const { permanent } = reroute;
+  const status = permanent ? 308 : 307;
+  const externalRedirect = validateExternalRedirect(reroute);
+  if (externalRedirect) {
+    log(`External ${type} found`, { [type]: externalRedirect, permanent });
+    return server.NextResponse.redirect(externalRedirect, { status });
+  }
+  log(`${radashi.capitalize(type)} found`, { [type]: reroute, permanent });
+  const { destination } = reroute;
+  const [destinationPathname, search] = splitDestination(destination);
+  if (search) url.search = search;
+  url.pathname = destinationPathname;
+  log(`${radashi.capitalize(type)}ing to ${url.toString()} with status ${status}`);
+  return server.NextResponse[type](url, { status });
+}
+async function fetchPageSettingsTranslation(path) {
+  const graphqlEndpoint = process.env.NEXT_SERVER_GRAPHQL_URL || process.env.NEXT_PUBLIC_GRAPHQL_URL;
+  const graphqlApiKey = process.env.NEXT_PUBLIC_API_TOKEN;
+  if (!graphqlEndpoint) {
+    throw new Error("Missing GraphQL configuration `graphqlEndpoint`");
+  }
+  if (!graphqlApiKey) {
+    throw new Error("Missing GraphQL configuration `graphqlApiKey`");
+  }
+  const query = `
+    query Languages_code($filter: page_settings_translations_filter) {
+      page_settings_translations(filter: $filter) {
+        languages_code {
+          code
+        }
+        id
+        page_settings_id {
+          belongs_to_collection
+          belongs_to_key
+        }
+        title
+        slug
+        path
+      }
+    }
+  `;
+  const variables = {
+    filter: {
+      path: { _eq: path },
+      _and: [{ page_settings_id: { belongs_to_key: { _nempty: true } } }]
+    }
+  };
+  try {
+    log("Executing GraphQL query:", query);
+    log("Query variables:", variables);
+    const response = await fetch(graphqlEndpoint, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${graphqlApiKey}`
+      },
+      body: JSON.stringify({ query, variables })
+    });
+    const { data } = await response.json();
+    log("GraphQL response:", data);
+    return data.page_settings_translations;
+  } catch (error) {
+    log("GraphQL Error:", error);
+    return null;
+  }
+}
+function removeLocaleFromPathname(pathname, config) {
+  const currentLocale = Object.values(config.localeMap ?? {}).find((locale) => pathname.startsWith(`/${locale}/`));
+  return { locale: currentLocale, pathname: currentLocale ? pathname.replace(`/${currentLocale}/`, "/") : pathname };
+}
+async function directusRouteRouter(request, config, NextResponse = server.NextResponse) {
+  var _a, _b, _c;
+  const { pathname: localizedPathname } = request.nextUrl;
+  const { locale, pathname } = removeLocaleFromPathname(localizedPathname, config);
+  log("Processing request for pathname:", { locale, pathname });
+  const redirect = await handleRedirect(request, (_a = config.modules) == null ? void 0 : _a.redirects);
+  if (redirect) {
+    return redirect;
+  }
+  const translations = await fetchPageSettingsTranslation(pathname);
+  if (!translations || translations.length === 0) {
+    log("No translation found for path:", pathname);
+    return NextResponse.next();
+  }
+  const translation = translations[0];
+  log("Using translation:", translation);
+  if (!translation.languages_code || !translation.page_settings_id) {
+    log(`Invalid translation data for path: ${pathname}`, { pathname }, "warn");
+    return NextResponse.next();
+  }
+  const directusLocale = translation.languages_code.code;
+  const collection = translation.page_settings_id.belongs_to_collection;
+  const id = translation.page_settings_id.belongs_to_key;
+  if (!collection) {
+    log(`PageSettings with id ${id} was found but is not associated with any collection.`, { id }, "warn");
+    return NextResponse.next();
+  }
+  const mappedLocale = ((_b = config.localeMap) == null ? void 0 : _b[directusLocale]) || directusLocale;
+  const idField = ((_c = config.collectionSettings[collection]) == null ? void 0 : _c.idField) || config.collectionSettings.default.idField;
+  log("Directus locale:", directusLocale);
+  log("Mapped locale:", mappedLocale);
+  log("Collection:", collection);
+  log("ID Field:", idField);
+  log("ID:", id);
+  const newPath = `/${mappedLocale}/${collection}/${id}`;
+  log(`Rewriting path: ${pathname} -> ${newPath}`);
+  const url = request.nextUrl.clone();
+  url.pathname = newPath;
+  log("Rewriting to URL:", url.toString());
+  return NextResponse.rewrite(url);
+}
+exports.directusRouteRouter = directusRouteRouter;
+exports.getApiRouteUrlDefault = getApiRouteUrlDefault;
+exports.getRedirectSecretDefault = getRedirectSecretDefault;
+exports.getRedirectsRoute = getRedirectsRoute;
+exports.handleRedirect = handleRedirect;
+exports.log = log;
+exports.logger = logger;

package/index.js

@@ -0,0 +1,291 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const headers = require("next/headers");
+const navigation = require("next/navigation");
+const radashi = require("radashi");
+const directusRouteRouter = require("./directusRouteRouter-CfK0xrh0.js");
+const logger = require("@okam/logger");
+const coreLib = require("@okam/core-lib");
+function getJsonErrorResponse(data, status) {
+  const headers2 = {
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    "Content-Type": "text/json; charset=UTF-8"
+  };
+  const body = JSON.stringify(data);
+  return new Response(body, {
+    status,
+    headers: headers2
+  });
+}
+function getDraftSecretDefault() {
+  return process.env.NEXT_API_DRAFT_SECRET || "";
+}
+function parseDraftParams(url) {
+  const { searchParams } = new URL(url);
+  const secret = searchParams.get("secret") || "";
+  const languagesParam = searchParams.get("languages");
+  const pathsParam = searchParams.get("urls");
+  const routesParam = searchParams.get("routes");
+  const pkParam = searchParams.get("pk");
+  const versionParam = searchParams.get("version");
+  const emptyReturn = {
+    secret: "",
+    languages: [],
+    paths: [],
+    routes: [],
+    type: "",
+    pk: "",
+    version: ""
+  };
+  if (!secret || !languagesParam || !(pathsParam || routesParam)) {
+    return emptyReturn;
+  }
+  const pk = typeof pkParam === "string" ? pkParam : "";
+  const version = typeof versionParam === "string" ? versionParam : "";
+  try {
+    const languages = JSON.parse(languagesParam);
+    if (routesParam) {
+      const routes = JSON.parse(routesParam);
+      return {
+        secret,
+        languages,
+        paths: [],
+        routes,
+        type: "route",
+        pk,
+        version
+      };
+    }
+    if (!pathsParam) {
+      return emptyReturn;
+    }
+    const paths = JSON.parse(pathsParam);
+    return {
+      secret,
+      languages,
+      paths,
+      routes: [],
+      type: "path",
+      pk,
+      version
+    };
+  } catch (e) {
+    return emptyReturn;
+  }
+}
+function getPathFromRoute(routeUrl, url, index = 0) {
+  const { searchParams } = new URL(url);
+  const matches = [...routeUrl.matchAll(/\{\{([a-z]+)\}\}/gi)];
+  const map = {};
+  matches.forEach((match) => {
+    const key = match[1] || "";
+    if (!key) {
+      return;
+    }
+    const listkey = `${key}s`;
+    const listParam = searchParams.get(listkey);
+    if (listParam) {
+      try {
+        const list = JSON.parse(listParam);
+        map[key] = list[index] || "";
+      } catch (e) {
+        map[key] = "";
+      }
+    } else {
+      const param = searchParams.get(key);
+      map[key] = param || "";
+    }
+  });
+  return radashi.template(routeUrl, map);
+}
+function handleDraftRoute({
+  url,
+  getDirectusLanguage,
+  getDraftSecret,
+  getJsonError
+}) {
+  const getSecretFunction = getDraftSecret || getDraftSecretDefault;
+  const getJsonErrorResponseFunction = getJsonError || getJsonErrorResponse;
+  const { secret, languages, paths, routes, type, version } = parseDraftParams(url);
+  if (secret !== getSecretFunction()) {
+    return getJsonErrorResponseFunction({ error: "Invalid argument" }, 401);
+  }
+  if (type === "") {
+    return getJsonErrorResponseFunction({ error: "Invalid argument" }, 400);
+  }
+  if (!Array.isArray(languages) || languages.length <= 0) {
+    return getJsonErrorResponseFunction({ error: "Invalid languages argument" }, 400);
+  }
+  if (type === "path" && (!Array.isArray(paths) || paths.length <= 0)) {
+    return getJsonErrorResponseFunction({ error: "Invalid paths argument" }, 400);
+  }
+  if (type === "route" && (!Array.isArray(routes) || routes.length <= 0)) {
+    return getJsonErrorResponseFunction({ error: "Invalid routes argument" }, 400);
+  }
+  const directusLang = getDirectusLanguage();
+  const indexDefault = languages.indexOf(directusLang);
+  const index = indexDefault !== -1 ? indexDefault : 0;
+  let redirectUrl = "";
+  if (type === "path") {
+    const path = paths[index] || "";
+    if (!path) {
+      return getJsonErrorResponse({ error: "Invalid path" }, 400);
+    }
+    redirectUrl = path;
+  } else if (type === "route") {
+    const route = routes[index] || "";
+    if (!route) {
+      return getJsonErrorResponse({ error: "Invalid route" }, 400);
+    }
+    const pathFromRoute = getPathFromRoute(route, url, index);
+    if (!pathFromRoute) {
+      return getJsonErrorResponse({ error: "Invalid route" }, 400);
+    }
+    redirectUrl = pathFromRoute;
+  }
+  if (redirectUrl && version) {
+    const withParams = redirectUrl.indexOf("?") !== -1;
+    redirectUrl = `${redirectUrl}${withParams ? "&" : "?"}version=${encodeURIComponent(version)}`;
+  }
+  headers.draftMode().enable();
+  navigation.redirect(redirectUrl);
+  return void 0;
+}
+function isRedirect(redirect) {
+  return !!redirect && typeof redirect === "object" && "source" in redirect && "destination" in redirect;
+}
+function normalizeRedirects(redirects) {
+  if (!redirects || !Array.isArray(redirects)) return [];
+  return redirects.flatMap((redirect) => {
+    const { source, destination, ...rest } = redirect ?? {};
+    if (!redirect || !source || !destination || !isRedirect(redirect)) return [];
+    return [
+      {
+        ...rest,
+        source: coreLib.normalizePath(source),
+        destination: coreLib.normalizePath(destination)
+      }
+    ];
+  });
+}
+const redirectDefaultLimit = 2e3;
+function getDefaultConfig() {
+  return {
+    graphqlEndpoint: process.env["NEXT_REDIRECT_GRAPHQL_URL"] || process.env["NEXT_PUBLIC_GRAPHQL_URL"] || "",
+    graphqlApiKey: process.env["NEXT_API_TOKEN_ADMIN"] || "",
+    redirectsFilename: "./redirect/redirects.json",
+    rewritesFilename: "./redirect/rewrites.json",
+    limit: redirectDefaultLimit
+  };
+}
+async function fetchRedirectsData(config, init) {
+  const {
+    graphqlApiKey: defaultGraphqlApiKey,
+    graphqlEndpoint: defaultGraphqlEndpoint,
+    limit: defaultLimit
+  } = getDefaultConfig();
+  const {
+    graphqlEndpoint = defaultGraphqlEndpoint,
+    graphqlApiKey = defaultGraphqlApiKey,
+    limit = defaultLimit
+  } = config;
+  if (!graphqlEndpoint) {
+    throw new Error(
+      "Missing fetchRedirects configuration `graphqlEndpoint`. Check environment variables NEXT_REDIRECT_GRAPHQL_URL or NEXT_PUBLIC_GRAPHQL_URL"
+    );
+  }
+  if (!graphqlApiKey) {
+    throw new Error(
+      "Missing fetchRedirects configuration `graphqlApiKey`. Check environment variable NEXT_API_TOKEN_ADMIN"
+    );
+  }
+  const query = `query fetchRedirects($limit: Int = 2000) {
+  redirects(filter: {status:{_eq:"published"},isrewrite:{_eq:false}}, sort: "sort", limit: $limit) {
+    source
+    destination
+    permanent
+    locale
+  }
+  rewrites: redirects(filter: {status:{_eq:"published"},isrewrite:{_eq:true}}, sort: "sort", limit: $limit) {
+    source
+    destination
+    permanent
+    locale
+  }
+}`;
+  const graphqlBody = {
+    query,
+    // "operationName": "",
+    variables: {
+      limit: Number(limit) || redirectDefaultLimit
+    }
+  };
+  try {
+    const response = await fetch(graphqlEndpoint, {
+      ...init,
+      method: "POST",
+      headers: {
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${graphqlApiKey}`
+      },
+      body: JSON.stringify(graphqlBody)
+    });
+    const { data } = await response.json();
+    const { redirects, rewrites } = data ?? {};
+    if (!(redirects == null ? void 0 : redirects.length) && !(rewrites == null ? void 0 : rewrites.length)) {
+      logger.logger.log("No redirects/rewrites found", "warn");
+      return {
+        redirects: [],
+        rewrites: []
+      };
+    }
+    logger.logger.log(`Fetch redirects count: ${(redirects == null ? void 0 : redirects.length) || 0}, rewrites count: ${(rewrites == null ? void 0 : rewrites.length) || 0}`);
+    return {
+      redirects: normalizeRedirects(redirects),
+      rewrites: normalizeRedirects(rewrites)
+    };
+  } catch (e) {
+    logger.logger.log(`Error fetching redirects: ${e.message}`, "error");
+  }
+  return {
+    redirects: [],
+    rewrites: []
+  };
+}
+function parseRedirectParams(url) {
+  const { searchParams } = new URL(url);
+  const secret = searchParams.get("secret") || "";
+  return { secret };
+}
+async function handleRedirectsRoute({
+  url,
+  getRedirectSecret = directusRouteRouter.getRedirectSecretDefault,
+  getJsonError = getJsonErrorResponse,
+  getDirectusApiToken,
+  getDirectusGraphqlUrl,
+  limit,
+  init
+}) {
+  const { secret } = parseRedirectParams(url);
+  if (secret !== getRedirectSecret()) {
+    return getJsonError({ error: "Invalid argument" }, 401);
+  }
+  const graphqlEndpoint = getDirectusGraphqlUrl == null ? void 0 : getDirectusGraphqlUrl();
+  const graphqlApiKey = getDirectusApiToken == null ? void 0 : getDirectusApiToken();
+  const { redirects, rewrites } = await fetchRedirectsData({ graphqlEndpoint, graphqlApiKey, limit }, init);
+  return new Response(JSON.stringify({ redirects, rewrites }), { status: 200 });
+}
+exports.DirectusNextLogger = directusRouteRouter.logger;
+exports.directusRouteRouter = directusRouteRouter.directusRouteRouter;
+exports.getApiRouteUrlDefault = directusRouteRouter.getApiRouteUrlDefault;
+exports.getRedirectSecretDefault = directusRouteRouter.getRedirectSecretDefault;
+exports.getRedirectsRoute = directusRouteRouter.getRedirectsRoute;
+exports.handleRedirect = directusRouteRouter.handleRedirect;
+exports.getDraftSecretDefault = getDraftSecretDefault;
+exports.getJsonErrorResponse = getJsonErrorResponse;
+exports.getPathFromRoute = getPathFromRoute;
+exports.handleDraftRoute = handleDraftRoute;
+exports.handleRedirectsRoute = handleRedirectsRoute;
+exports.parseDraftParams = parseDraftParams;
+exports.parseRedirectParams = parseRedirectParams;