@preprio/toolkit 0.6.0-alpha.1 → 0.6.0-alpha.10

package/dist/nextjs/chunk-B4GVZEOL.js

@@ -0,0 +1,549 @@
+// src/nextjs/middleware.ts
+import { NextResponse } from "next/server";
+
+// src/version.ts
+var VERSION = "0.6.0-alpha.10";
+
+// src/core/constants.ts
+var COOKIE_PREVIEW_MODE = "Prepr-Preview-Mode";
+var COOKIE_SEGMENT = "Prepr-Segments";
+var COOKIE_VARIANT = "Prepr-ABtesting";
+var COOKIE_UID = "__prepr_uid";
+var COOKIE_HUBSPOT = "hubspotutk";
+var PARAM_SEGMENT = "prepr_preview_segment";
+var PARAM_VARIANT = "prepr_preview_ab";
+var PARAM_HIDE_BAR = "prepr_hide_bar";
+var ONE_YEAR_SECONDS = 60 * 60 * 24 * 365;
+
+// src/core/features.ts
+function isEnabled(config) {
+  if (typeof config === "boolean") return config;
+  return config?.enabled ?? true;
+}
+function resolveFeatures(features) {
+  return {
+    segments: isEnabled(features?.segments),
+    abTesting: isEnabled(features?.abTesting),
+    editMode: isEnabled(features?.editMode)
+  };
+}
+var ALL_FEATURES_ENABLED = Object.freeze({
+  segments: true,
+  abTesting: true,
+  editMode: true
+});
+
+// src/core/middleware.ts
+var UTM_PARAMS = [
+  "utm_source",
+  "utm_medium",
+  "utm_term",
+  "utm_content",
+  "utm_campaign"
+];
+var MAX_HEADER_VALUE_LENGTH = 2048;
+function sanitizeHeaderValue(value) {
+  const stripped = value.replace(/[\u0000-\u001f\u007f]/g, "");
+  return stripped.length > MAX_HEADER_VALUE_LENGTH ? stripped.slice(0, MAX_HEADER_VALUE_LENGTH) : stripped;
+}
+function parseCookies(request) {
+  const cookies2 = /* @__PURE__ */ new Map();
+  const header = request.headers.get("cookie");
+  if (!header) return cookies2;
+  for (const part of header.split(";")) {
+    const eq = part.indexOf("=");
+    if (eq === -1) continue;
+    const name = part.slice(0, eq).trim();
+    const value = part.slice(eq + 1).trim();
+    if (!name) continue;
+    try {
+      cookies2.set(name, decodeURIComponent(value));
+    } catch {
+      cookies2.set(name, value);
+    }
+  }
+  return cookies2;
+}
+function processFrameworkRequest(request, opts, framework) {
+  const requestHeaders = new Headers(request.headers);
+  const responseCookies = [];
+  const inboundPreprHeaders = [];
+  requestHeaders.forEach((_value, key) => {
+    if (key.toLowerCase().startsWith("prepr-")) {
+      inboundPreprHeaders.push(key);
+    }
+  });
+  for (const key of inboundPreprHeaders) {
+    requestHeaders.delete(key);
+  }
+  const requestCookies = parseCookies(request);
+  const url = new URL(request.url);
+  const searchParams = url.searchParams;
+  const forwardedProto = request.headers.get("x-forwarded-proto")?.split(",")[0]?.trim();
+  const isSecure = forwardedProto ? forwardedProto === "https" : url.protocol === "https:";
+  const crossSite = isSecure ? { sameSite: "None", secure: true } : {};
+  for (const key of UTM_PARAMS) {
+    const value = searchParams.get(key);
+    if (value !== null) {
+      requestHeaders.set(`Prepr-Context-${key}`, sanitizeHeaderValue(value));
+    }
+  }
+  const referer = request.headers.get("referer");
+  if (referer) {
+    requestHeaders.set(
+      "Prepr-Context-initial_referral",
+      sanitizeHeaderValue(referer)
+    );
+  }
+  const userAgent = request.headers.get("user-agent");
+  if (userAgent) {
+    requestHeaders.set("User-Agent", sanitizeHeaderValue(userAgent));
+  }
+  const packageParts = [`@preprio/toolkit@${opts?.version ?? VERSION}`];
+  if (framework) packageParts.push(`framework=${framework}`);
+  packageParts.push(`preview=${opts?.preview ? "true" : "false"}`);
+  requestHeaders.set("Prepr-Package", packageParts.join("; "));
+  const ip = request.headers.get("Cf-Connecting-Ip") ?? request.headers.get("x-real-ip");
+  if (ip) {
+    requestHeaders.set("Prepr-Visitor-IP", sanitizeHeaderValue(ip));
+  }
+  const hutkCookie = requestCookies.get(COOKIE_HUBSPOT);
+  if (hutkCookie) {
+    requestHeaders.set("Prepr-Hubspot-Id", sanitizeHeaderValue(hutkCookie));
+  }
+  let uid = sanitizeHeaderValue(requestCookies.get(COOKIE_UID) ?? "");
+  if (!uid) {
+    uid = crypto.randomUUID();
+    responseCookies.push({
+      name: COOKIE_UID,
+      value: uid,
+      maxAge: ONE_YEAR_SECONDS,
+      path: "/"
+    });
+    requestHeaders.set("Prepr-Customer-Id-Created", "true");
+  }
+  requestHeaders.set("Prepr-Customer-Id", uid);
+  if (!opts?.preview) {
+    return { requestHeaders, responseCookies };
+  }
+  const features = resolveFeatures(opts?.features);
+  const hasPreviewParams = features.segments && searchParams.has(PARAM_SEGMENT) || features.abTesting && searchParams.has(PARAM_VARIANT);
+  if (!hasPreviewParams) {
+    const previewModeCookie = requestCookies.get(COOKIE_PREVIEW_MODE);
+    const previewModeEnabled = previewModeCookie !== "false";
+    if (!previewModeEnabled) {
+      return { requestHeaders, responseCookies };
+    }
+  }
+  requestHeaders.set("Prepr-Preview-Bar", "true");
+  const isLivePreview = searchParams.get(PARAM_HIDE_BAR) === "true";
+  if (!isLivePreview && !requestCookies.has(COOKIE_PREVIEW_MODE)) {
+    responseCookies.push({
+      name: COOKIE_PREVIEW_MODE,
+      value: "true",
+      maxAge: ONE_YEAR_SECONDS,
+      path: "/",
+      ...crossSite
+    });
+  }
+  if (!isLivePreview) {
+    const segmentCookie = features.segments ? requestCookies.get(COOKIE_SEGMENT) : void 0;
+    if (segmentCookie) {
+      requestHeaders.set("Prepr-Segments", sanitizeHeaderValue(segmentCookie));
+    }
+    const abCookie = features.abTesting ? requestCookies.get(COOKIE_VARIANT) : void 0;
+    if (abCookie) {
+      requestHeaders.set("Prepr-ABtesting", sanitizeHeaderValue(abCookie));
+    }
+  }
+  const previewAb = features.abTesting ? searchParams.get(PARAM_VARIANT) : null;
+  if (previewAb !== null) {
+    requestHeaders.set("Prepr-ABtesting", sanitizeHeaderValue(previewAb));
+    if (!isLivePreview) {
+      responseCookies.push({
+        name: COOKIE_VARIANT,
+        value: previewAb,
+        maxAge: ONE_YEAR_SECONDS,
+        path: "/",
+        ...crossSite
+      });
+    }
+  }
+  const previewSegment = features.segments ? searchParams.get(PARAM_SEGMENT) : null;
+  if (previewSegment !== null) {
+    requestHeaders.set("Prepr-Segments", sanitizeHeaderValue(previewSegment));
+    if (!isLivePreview) {
+      responseCookies.push({
+        name: COOKIE_SEGMENT,
+        value: previewSegment,
+        maxAge: ONE_YEAR_SECONDS,
+        path: "/",
+        ...crossSite
+      });
+    }
+  }
+  if (requestHeaders.has("Prepr-Segments")) {
+    requestHeaders.delete("Prepr-Customer-Id");
+    requestHeaders.delete("Prepr-Customer-Id-Created");
+  }
+  return { requestHeaders, responseCookies };
+}
+
+// src/nextjs/middleware.ts
+function createPreprMiddleware(request, responseOrOptions, maybeOptions) {
+  let chainedResponse;
+  let options;
+  if (responseOrOptions instanceof NextResponse) {
+    chainedResponse = responseOrOptions;
+    options = maybeOptions;
+  } else {
+    options = responseOrOptions;
+  }
+  const { requestHeaders, responseCookies } = processFrameworkRequest(
+    request,
+    options,
+    "nextjs"
+  );
+  const response = chainedResponse ?? NextResponse.next({ request: { headers: requestHeaders } });
+  if (chainedResponse) {
+    const existing = response.headers.get("x-middleware-override-headers");
+    const names = new Set(
+      existing ? existing.split(",").map((name) => name.trim()).filter(Boolean) : []
+    );
+    requestHeaders.forEach((value, key) => {
+      names.add(key);
+      response.headers.set(`x-middleware-request-${key}`, value);
+    });
+    response.headers.set("x-middleware-override-headers", [...names].join(","));
+  }
+  for (const cookie of responseCookies) {
+    response.cookies.set(cookie.name, cookie.value, {
+      maxAge: cookie.maxAge,
+      path: cookie.path,
+      // Lower-cased: Next's cookie API expects 'none' | 'lax' | 'strict'.
+      ...cookie.sameSite ? {
+        sameSite: cookie.sameSite.toLowerCase()
+      } : {},
+      ...cookie.secure ? { secure: true } : {}
+    });
+  }
+  return response;
+}
+
+// src/core/server.ts
+var PreprError = class extends Error {
+  constructor(message, code, context, originalError) {
+    super(message);
+    this.code = code;
+    this.context = context;
+    this.originalError = originalError;
+    this.name = "PreprError";
+  }
+};
+function getPreprUUIDFromHeaders(headers2) {
+  return headers2.get("prepr-customer-id");
+}
+function getActiveSegmentFromHeaders(headers2) {
+  return headers2.get("Prepr-Segments");
+}
+function getActiveVariantFromHeaders(headers2) {
+  return headers2.get("Prepr-ABtesting");
+}
+var PREPR_HEADER_KEYS = [
+  "prepr-customer-id",
+  "Prepr-Segments",
+  "Prepr-ABtesting",
+  "Prepr-Preview-Bar",
+  "Prepr-Context-utm_source",
+  "Prepr-Context-utm_medium",
+  "Prepr-Context-utm_term",
+  "Prepr-Context-utm_content",
+  "Prepr-Context-utm_campaign",
+  "Prepr-Context-initial_referral",
+  "Prepr-Visitor-IP",
+  "Prepr-Hubspot-Id",
+  "Prepr-Customer-Id-Created",
+  "User-Agent",
+  "Prepr-Package"
+];
+function getPreprHeadersFromHeaders(headers2) {
+  const preprHeaders = {};
+  const copy = (key) => {
+    const value = headers2.get(key);
+    if (value !== null) {
+      preprHeaders[key] = value;
+    }
+  };
+  for (const key of PREPR_HEADER_KEYS) {
+    copy(key);
+  }
+  return preprHeaders;
+}
+function validatePreprToken(token) {
+  if (!token) {
+    throw new PreprError(
+      "Token is required",
+      "MISSING_TOKEN",
+      "validatePreprToken"
+    );
+  }
+  if (!token.startsWith("https://")) {
+    throw new PreprError(
+      "Token must be a valid HTTPS URL",
+      "INVALID_TOKEN",
+      "validatePreprToken"
+    );
+  }
+}
+function extractAccessToken(graphqlUrl) {
+  let url;
+  try {
+    url = new URL(graphqlUrl);
+  } catch (error) {
+    throw new PreprError(
+      "Token must be a valid URL",
+      "INVALID_TOKEN",
+      "extractAccessToken",
+      error instanceof Error ? error : new Error(String(error))
+    );
+  }
+  if (url.hostname !== "graphql.prepr.io") {
+    throw new PreprError(
+      "Token must be a graphql.prepr.io URL",
+      "INVALID_TOKEN",
+      "extractAccessToken"
+    );
+  }
+  const pathParts = url.pathname.split("/");
+  const token = pathParts[pathParts.length - 1];
+  if (!token) {
+    throw new PreprError(
+      "Token URL is missing an access token segment",
+      "INVALID_TOKEN",
+      "extractAccessToken"
+    );
+  }
+  return token;
+}
+async function getPreprEnvironmentSegments(token) {
+  validatePreprToken(token);
+  try {
+    const response = await fetch(token, {
+      headers: {
+        "Prepr-Package": `@preprio/toolkit@${VERSION}`,
+        // Duplicates the version in Prepr-Package. It keeps the User-Agent
+        // format used by `@preprio/prepr-nextjs`, for Prepr API consumers that
+        // still identify the toolbar by that string.
+        "User-Agent": `Prepr-Preview-Bar/${VERSION}`,
+        "Content-Type": "application/json"
+      },
+      method: "POST",
+      body: JSON.stringify({
+        query: `{
+                _Segments {
+                    _id
+                    name
+                }
+            }`
+      })
+    });
+    if (!response.ok) {
+      throw new PreprError(
+        `HTTP ${response.status}: ${response.statusText}`,
+        "HTTP_ERROR",
+        "getPreprEnvironmentSegments"
+      );
+    }
+    const json = await response.json();
+    if (!json || !json.data || !json.data._Segments) {
+      throw new PreprError(
+        "Invalid response format from Prepr API",
+        "INVALID_RESPONSE",
+        "getPreprEnvironmentSegments"
+      );
+    }
+    return json.data._Segments;
+  } catch (error) {
+    if (error instanceof PreprError) {
+      throw error;
+    }
+    throw new PreprError(
+      "Failed to fetch segments from Prepr API",
+      "FETCH_ERROR",
+      "getPreprEnvironmentSegments",
+      error instanceof Error ? error : new Error(String(error))
+    );
+  }
+}
+async function getToolbarPropsFromHeaders(headers2, token, features) {
+  const resolved = resolveFeatures(features);
+  let segments = [];
+  if (resolved.segments) {
+    try {
+      segments = await getPreprEnvironmentSegments(token);
+    } catch {
+      segments = [];
+    }
+  }
+  return {
+    activeSegment: resolved.segments ? getActiveSegmentFromHeaders(headers2) : null,
+    activeVariant: resolved.abTesting ? getActiveVariantFromHeaders(headers2) : null,
+    segments,
+    data: segments
+  };
+}
+
+// src/nextjs/server.ts
+import { headers } from "next/headers";
+async function readHeaders() {
+  return await headers();
+}
+async function getPreprUUID() {
+  const h = await readHeaders();
+  return getPreprUUIDFromHeaders(h);
+}
+async function getActiveSegment() {
+  const h = await readHeaders();
+  return getActiveSegmentFromHeaders(h);
+}
+async function getActiveVariant() {
+  const h = await readHeaders();
+  return getActiveVariantFromHeaders(h);
+}
+async function getPreprHeaders() {
+  const h = await readHeaders();
+  return getPreprHeadersFromHeaders(h);
+}
+async function getToolbarProps(token, features) {
+  const h = await readHeaders();
+  return getToolbarPropsFromHeaders(h, token, features);
+}
+
+// src/core/personalization.ts
+var PERSONALIZED_VARY = /\bPrepr-(Segments|ABTesting)/i;
+function isPersonalizedResponse(source) {
+  const headers2 = "headers" in source ? source.headers : source;
+  return PERSONALIZED_VARY.test(headers2.get("vary") ?? "");
+}
+
+// src/nextjs/draft.ts
+import { cookies, draftMode } from "next/headers";
+import { redirect } from "next/navigation";
+import { NextResponse as NextResponse2 } from "next/server";
+var DRAFT_COOKIE = "__prerender_bypass";
+var RETURN_PARAM = "prepr_draft";
+var DEFAULT_ROUTE = "/api/prepr/draft";
+function preprDraftRedirect(request, options) {
+  if (!options.preview) return null;
+  if (request.method !== "GET" && request.method !== "HEAD") return null;
+  const url = request.nextUrl;
+  if (url.pathname === (options.route ?? DEFAULT_ROUTE)) return null;
+  if (request.cookies.has(DRAFT_COOKIE)) {
+    if (!url.searchParams.has(RETURN_PARAM)) return null;
+    const clean = url.clone();
+    clean.searchParams.delete(RETURN_PARAM);
+    return NextResponse2.redirect(clean, 307);
+  }
+  if (url.searchParams.has(RETURN_PARAM)) return null;
+  const target = new URL(options.route ?? DEFAULT_ROUTE, request.url);
+  target.searchParams.set("to", url.pathname + url.search);
+  return NextResponse2.redirect(target, 307);
+}
+function createPreprDraftRoute(options) {
+  return async (request) => {
+    if (!options.preview) return new Response("Not found", { status: 404 });
+    (await draftMode()).enable();
+    const self = new URL(request.url);
+    if (self.protocol === "https:") {
+      const jar = await cookies();
+      const draft = jar.get(DRAFT_COOKIE);
+      if (draft) {
+        jar.set({
+          name: DRAFT_COOKIE,
+          value: draft.value,
+          path: "/",
+          httpOnly: true,
+          secure: true,
+          sameSite: "none",
+          partitioned: true
+        });
+      }
+    }
+    let to = new URL(self.searchParams.get("to") ?? "/", self);
+    if (to.origin !== self.origin) to = new URL("/", self);
+    to.searchParams.set(RETURN_PARAM, "1");
+    redirect(to.pathname + to.search);
+  };
+}
+
+// src/core/graphql/cache-tags.ts
+var MAX_TAGS = 128;
+var MAX_TAG_LENGTH = 256;
+var PREPR_ANY_ITEM_TAG = "prepr:any";
+var PREPR_SCHEMA_TAG = "prepr:schema";
+var preprItemTag = (id) => `prepr:${id}`;
+var NOT_ALPHANUMERIC = /[^a-z0-9]/g;
+var preprModelTag = (model) => `prepr:model:${model.toLowerCase().replace(NOT_ALPHANUMERIC, "")}`;
+function preprModelTagsFor(document, data, schema) {
+  const operation = document.definitions.find(
+    (definition) => definition.kind === "OperationDefinition" && definition.operation === "query"
+  );
+  const root = schema.types[schema.queryType];
+  if (!operation || !root) return [];
+  const models = (type) => {
+    const members = schema.types[type]?.possibleTypes ?? [];
+    return members.length > 0 ? members : [type];
+  };
+  const tags = /* @__PURE__ */ new Set();
+  for (const selection of operation.selectionSet.selections) {
+    if (selection.kind !== "Field") continue;
+    const type = root.fields[selection.name.value]?.type;
+    const info = type ? schema.types[type] : void 0;
+    if (!type || !info) continue;
+    const items = info.fields.items?.type;
+    const key = (selection.alias ?? selection.name).value;
+    const found = typeof data === "object" && data !== null && data[key] != null;
+    const affected = items ? models(items) : found ? [] : models(type);
+    for (const model of affected) tags.add(preprModelTag(model));
+  }
+  return [...tags];
+}
+function preprCacheTags(data) {
+  const tags = /* @__PURE__ */ new Set();
+  const stack = [data];
+  while (stack.length > 0) {
+    const value = stack.pop();
+    if (typeof value !== "object" || value === null) continue;
+    const id = value._id;
+    if (typeof id === "string" && id !== "") {
+      const tag = preprItemTag(id);
+      if (tag.length > MAX_TAG_LENGTH) return [PREPR_ANY_ITEM_TAG];
+      tags.add(tag);
+      if (tags.size > MAX_TAGS) return [PREPR_ANY_ITEM_TAG];
+    }
+    for (const child of Object.values(value)) stack.push(child);
+  }
+  return [...tags];
+}
+
+export {
+  createPreprMiddleware,
+  PreprError,
+  getPreprHeadersFromHeaders,
+  validatePreprToken,
+  extractAccessToken,
+  getPreprUUID,
+  getActiveSegment,
+  getActiveVariant,
+  getPreprHeaders,
+  getToolbarProps,
+  isPersonalizedResponse,
+  preprDraftRedirect,
+  createPreprDraftRoute,
+  PREPR_ANY_ITEM_TAG,
+  PREPR_SCHEMA_TAG,
+  preprItemTag,
+  preprModelTag,
+  preprModelTagsFor,
+  preprCacheTags
+};