@hawk.so/nextjs 0.0.0-stage → 1.1.0

package/dist/config.d.ts

@@ -0,0 +1,75 @@
+/// <reference path="../global.d.ts" />
+import { NextConfig } from 'next';
+
+/**
+ * Options of the commits collecting
+ */
+interface CommitsOptions {
+    /**
+     * Path to the repository with `.git` directory. Default is the Next.js project directory
+     */
+    repo?: string;
+    /**
+     * How many recent commits to send. Default is 5
+     */
+    number?: number;
+}
+
+/**
+ * Options of the Hawk Next.js integration
+ */
+interface HawkNextOptions {
+    /**
+     * Hawk Integration Token. Default is the HAWK_TOKEN or NEXT_PUBLIC_HAWK_TOKEN environment variable
+     */
+    token?: string;
+    /**
+     * Unique identifier of the release.
+     * Default is HAWK_RELEASE environment variable, commit SHA from CI or git, or the build time
+     */
+    release?: string | number;
+    /**
+     * Whether to remove client source maps after sending. Default is true
+     */
+    removeSourceMaps?: boolean;
+    /**
+     * Options for sending recent commits with the release, or false to skip. Enabled by default
+     */
+    commits?: boolean | CommitsOptions;
+    /**
+     * Collector endpoint overwrite
+     */
+    collectorEndpoint?: string;
+}
+/**
+ * Context passed by Next.js to the config function
+ */
+interface NextConfigContext {
+    /**
+     * Default Next.js config
+     */
+    defaultConfig: NextConfig;
+}
+/**
+ * Next.js config exported as a function
+ */
+type NextConfigFunction = (phase: string, context: NextConfigContext) => NextConfig | Promise<NextConfig>;
+/**
+ * Wraps Next.js config to send releases with source maps to Hawk.
+ *
+ * - exposes the release id to the app code as `process.env.HAWK_RELEASE`
+ * - enables client source maps for production builds
+ * - after `next build` sends client source maps and recent commits to Hawk and removes the maps
+ * @param nextConfig - Next.js config object
+ * @param options - Hawk plugin options
+ */
+declare function withHawkConfig(nextConfig: NextConfig, options?: HawkNextOptions): NextConfig;
+/**
+ * Wraps Next.js config function to send releases with source maps to Hawk
+ * @param nextConfig - function returning Next.js config
+ * @param options - Hawk plugin options
+ */
+declare function withHawkConfig(nextConfig: NextConfigFunction, options?: HawkNextOptions): NextConfigFunction;
+
+export { withHawkConfig };
+export type { CommitsOptions, HawkNextOptions, NextConfigFunction };

package/dist/config.js

@@ -0,0 +1,533 @@
+// src/config/with-hawk-config.ts
+import { createRequire } from "module";
+import path5 from "path";
+import process2 from "process";
+
+// src/config/instrumentation.ts
+import { access } from "fs/promises";
+import path from "path";
+var DEFAULT_PAGE_EXTENSIONS = ["tsx", "ts", "jsx", "js"];
+var INSTRUMENTATION_FILES = ["instrumentation", "instrumentation-client"];
+async function exists(filePath) {
+  try {
+    await access(filePath);
+    return true;
+  } catch (_error) {
+    return false;
+  }
+}
+async function findMissingInstrumentationFiles(projectDir, pageExtensions = DEFAULT_PAGE_EXTENSIONS) {
+  const missing = [];
+  for (const name of INSTRUMENTATION_FILES) {
+    const candidates = ["", "src"].flatMap((dir) => pageExtensions.map((extension) => path.join(projectDir, dir, `${name}.${extension}`)));
+    const found = await Promise.all(candidates.map(exists));
+    if (!found.includes(true)) {
+      missing.push(name);
+    }
+  }
+  return missing;
+}
+
+// src/config/release.ts
+import { execFileSync } from "child_process";
+import process from "process";
+var RELEASE_ENV_VARIABLE = "HAWK_RELEASE";
+var COMMIT_SHA_ENV_VARIABLES = [
+  "GITHUB_SHA",
+  "CI_COMMIT_SHA",
+  "CI_MERGE_REQUEST_SOURCE_BRANCH_SHA",
+  "BITBUCKET_COMMIT",
+  "CIRCLE_SHA1",
+  "BUILDKITE_COMMIT",
+  "DRONE_COMMIT_SHA",
+  "TRAVIS_COMMIT",
+  "VERCEL_GIT_COMMIT_SHA",
+  "CF_PAGES_COMMIT_SHA",
+  "RAILWAY_GIT_COMMIT_SHA",
+  "RENDER_GIT_COMMIT",
+  "HEROKU_BUILD_COMMIT",
+  "SOURCE_VERSION",
+  "GIT_COMMIT",
+  "COMMIT_REF"
+];
+function getGitRevision(cwd) {
+  try {
+    const revision = execFileSync("git", ["rev-parse", "HEAD"], {
+      cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    return revision !== "" ? revision : void 0;
+  } catch (_error) {
+    return void 0;
+  }
+}
+function resolveRelease(release, cwd) {
+  if (release !== void 0 && String(release) !== "") {
+    return String(release);
+  }
+  const candidates = [RELEASE_ENV_VARIABLE, ...COMMIT_SHA_ENV_VARIABLES].map((name) => process.env[name]);
+  const fromEnv = candidates.find((value) => value !== void 0 && value !== "");
+  if (fromEnv !== void 0) {
+    return fromEnv;
+  }
+  return getGitRevision(cwd) ?? (/* @__PURE__ */ new Date()).toISOString();
+}
+
+// src/config/token.ts
+import { Buffer } from "buffer";
+function getIntegrationId(token) {
+  try {
+    const payload = JSON.parse(Buffer.from(token, "base64").toString("utf-8"));
+    if (typeof payload.integrationId === "string" && payload.integrationId !== "") {
+      return payload.integrationId;
+    }
+  } catch (_error) {
+  }
+  return void 0;
+}
+function getDefaultCollectorEndpoint(integrationId) {
+  return `https://${integrationId}.k1.hawk.so/release`;
+}
+
+// src/config/upload-release.ts
+import { readFile as readFile2 } from "fs/promises";
+
+// src/config/cleanup.ts
+import { readFile, unlink, writeFile } from "fs/promises";
+import path4 from "path";
+
+// src/config/sourcemaps.ts
+import { createHash } from "crypto";
+import { access as access2 } from "fs/promises";
+import path3 from "path";
+
+// src/config/utils/fs.ts
+import { Buffer as Buffer2 } from "buffer";
+import { open, readdir } from "fs/promises";
+import path2 from "path";
+var MAX_PARALLEL_FILE_OPERATIONS = 16;
+async function listFiles(dir) {
+  try {
+    const entries = await readdir(dir, { withFileTypes: true });
+    const files = await Promise.all(entries.map(async (entry) => {
+      if (entry.isDirectory()) {
+        return (await listFiles(path2.join(dir, entry.name))).map((file) => `${entry.name}/${file}`);
+      }
+      return entry.isFile() ? [entry.name] : [];
+    }));
+    return files.flat();
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return [];
+    }
+    throw error;
+  }
+}
+async function readFileTail(filePath, maxBytes) {
+  const file = await open(filePath, "r");
+  try {
+    const { size } = await file.stat();
+    const length = Math.min(maxBytes, size);
+    const { bytesRead, buffer } = await file.read(Buffer2.alloc(length), 0, length, size - length);
+    const tail = buffer.subarray(0, bytesRead).toString("utf8");
+    if (length === size) {
+      return tail;
+    }
+    const cutLineEnd = tail.indexOf("\n");
+    return cutLineEnd === -1 ? "" : tail.slice(cutLineEnd);
+  } finally {
+    await file.close();
+  }
+}
+
+// src/config/utils/pool.ts
+async function mapConcurrently(items, limit, mapper) {
+  const results = [];
+  let nextIndex = 0;
+  const runWorker = async () => {
+    while (nextIndex < items.length) {
+      const index = nextIndex;
+      nextIndex += 1;
+      results[index] = await mapper(items[index]);
+    }
+  };
+  const workersCount = Math.max(1, Math.min(limit, items.length));
+  await Promise.all(Array.from({ length: workersCount }, runWorker));
+  return results;
+}
+
+// src/config/sourcemaps.ts
+var STATIC_DIR = "static";
+var PUBLIC_PATH_PREFIX = "/_next/";
+var PATH_HASH_LENGTH = 8;
+var CHUNK_TAIL_SIZE = 4096;
+var JS_SOURCE_MAPPING_URL = /(?:^|\n)\/\/[#@] sourceMappingURL=([^\s'"`*]+)\s*$/;
+var SOURCE_PATH_PREFIXES = [
+  /^turbopack:\/\/\/\[project\]\//,
+  /^webpack:\/\/[^/]*\/(\.\/)?/
+];
+function isRawSourceMap(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function normalizeSourcePath(source) {
+  const prefix = SOURCE_PATH_PREFIXES.find((pattern) => pattern.test(source));
+  return prefix !== void 0 ? source.replace(prefix, "") : source;
+}
+function normalizeSources(map) {
+  if (Array.isArray(map.sources)) {
+    map.sources = map.sources.map((source) => typeof source === "string" ? normalizeSourcePath(source) : source);
+  }
+}
+function getSourceMapPath(chunk, content) {
+  const url = JS_SOURCE_MAPPING_URL.exec(content)?.[1];
+  if (url === void 0 || url.startsWith("/") || /^[a-z][a-z\d+.-]*:/i.test(url)) {
+    return void 0;
+  }
+  try {
+    const mapPath = path3.posix.join(path3.posix.dirname(chunk), decodeURIComponent(url));
+    return mapPath.startsWith("../") ? void 0 : mapPath;
+  } catch (_error) {
+    return void 0;
+  }
+}
+function encodeUrlPath(filePath) {
+  return filePath.split("/").map((segment) => encodeURIComponent(segment)).join("/");
+}
+function getSourceMapName(chunk) {
+  const extension = path3.posix.extname(chunk);
+  const hash = createHash("sha256").update(chunk).digest("hex").slice(0, PATH_HASH_LENGTH);
+  return `${path3.posix.basename(chunk, extension)}.${hash}${extension}.map`;
+}
+async function fileExists(filePath) {
+  try {
+    await access2(filePath);
+    return true;
+  } catch (_error) {
+    return false;
+  }
+}
+async function findClientSourceMaps(distDir) {
+  const staticDir = path3.join(distDir, STATIC_DIR);
+  const chunks = (await listFiles(staticDir)).filter((entry) => /\.[cm]?js$/.test(entry)).sort();
+  const maps = await mapConcurrently(chunks, MAX_PARALLEL_FILE_OPERATIONS, async (chunk) => {
+    const mapPath = getSourceMapPath(chunk, await readFileTail(path3.join(staticDir, chunk), CHUNK_TAIL_SIZE));
+    if (mapPath === void 0 || !await fileExists(path3.join(staticDir, mapPath))) {
+      return void 0;
+    }
+    return {
+      path: path3.join(staticDir, mapPath),
+      chunkUrl: `${PUBLIC_PATH_PREFIX}${STATIC_DIR}/${encodeUrlPath(chunk)}`,
+      name: getSourceMapName(chunk)
+    };
+  });
+  return maps.filter((map) => map !== void 0);
+}
+function prepareSourceMap(content, chunkUrl) {
+  const map = JSON.parse(content);
+  if (!isRawSourceMap(map)) {
+    throw new Error("Source map is not a JSON object");
+  }
+  map.file = chunkUrl;
+  normalizeSources(map);
+  if (Array.isArray(map.sections)) {
+    for (const section of map.sections) {
+      const sectionMap = isRawSourceMap(section) ? section.map : void 0;
+      if (isRawSourceMap(sectionMap)) {
+        normalizeSources(sectionMap);
+      }
+    }
+  }
+  return JSON.stringify(map);
+}
+
+// src/config/cleanup.ts
+var CSS_SOURCE_MAPPING_URL = /(?:^|\n)\/\*[#@] sourceMappingURL=[^\s*]+\s*\*\/\s*$/;
+async function deleteClientSourceMaps(distDir) {
+  const staticDir = path4.join(distDir, STATIC_DIR);
+  const maps = (await listFiles(staticDir)).filter((entry) => entry.endsWith(".map"));
+  await mapConcurrently(maps, MAX_PARALLEL_FILE_OPERATIONS, (entry) => unlink(path4.join(staticDir, entry)));
+  return maps.length;
+}
+async function stripSourceMappingUrlComments(distDir) {
+  const staticDir = path4.join(distDir, STATIC_DIR);
+  const assets = (await listFiles(staticDir)).filter((entry) => /\.([cm]?js|css)$/.test(entry));
+  const updated = await mapConcurrently(assets, MAX_PARALLEL_FILE_OPERATIONS, async (entry) => {
+    const filePath = path4.join(staticDir, entry);
+    const pattern = entry.endsWith(".css") ? CSS_SOURCE_MAPPING_URL : JS_SOURCE_MAPPING_URL;
+    const content = await readFile(filePath, "utf8");
+    const stripped = content.replace(pattern, "");
+    if (stripped === content) {
+      return false;
+    }
+    await writeFile(filePath, stripped);
+    return true;
+  });
+  return updated.filter(Boolean).length;
+}
+
+// src/config/commits.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+var FIELD_SEPARATOR = "";
+var RECORD_SEPARATOR = "";
+async function getCommits(repo, count) {
+  const { stdout } = await execFileAsync("git", [
+    "log",
+    `--max-count=${count}`,
+    "--format=%H%x1f%s%x1f%ae%x1f%aI%x1e"
+  ], {
+    cwd: repo,
+    encoding: "utf8"
+  });
+  return stdout.split(RECORD_SEPARATOR).map((record) => record.trim()).filter((record) => record !== "").map((record) => {
+    const [hash, title, author, date] = record.split(FIELD_SEPARATOR);
+    return {
+      hash,
+      title,
+      author,
+      date
+    };
+  });
+}
+
+// src/config/uploader.ts
+var MAX_RESPONSE_PREVIEW_LENGTH = 200;
+function sanitizeCollectorMessage(message) {
+  return message.startsWith("Integration token invalid") ? "Integration token invalid" : message;
+}
+async function send(collector, body) {
+  const response = await fetch(collector.endpoint, {
+    method: "POST",
+    body,
+    headers: [["Authorization", `Bearer ${collector.token}`]],
+    signal: AbortSignal.timeout(collector.timeout)
+  });
+  const text = await response.text();
+  let data;
+  try {
+    data = JSON.parse(text);
+  } catch (_error) {
+    throw new Error(`Unexpected collector response (HTTP ${response.status}): ${text.slice(0, MAX_RESPONSE_PREVIEW_LENGTH)}`);
+  }
+  if (data.error === true || !response.ok) {
+    throw new Error(sanitizeCollectorMessage(data.message ?? `HTTP ${response.status}`));
+  }
+}
+async function sendSourceMap(collector, name, content) {
+  const body = new FormData();
+  body.set("release", collector.release);
+  body.set("file", new Blob([content], { type: "application/json" }), name);
+  await send(collector, body);
+}
+async function sendCommits(collector, commits) {
+  const body = new FormData();
+  body.set("release", collector.release);
+  body.set("commits", JSON.stringify(commits));
+  await send(collector, body);
+}
+
+// src/config/utils/log.ts
+var consoleColors = {
+  fgRed: 31,
+  fgGreen: 32,
+  fgYellow: 33,
+  fgCyan: 36
+};
+function wrapInColor(message, color) {
+  return `\x1B[${color}m${message}\x1B[0m`;
+}
+function log(message, color = consoleColors.fgCyan) {
+  console.log(wrapInColor("\u{1F985} Hawk | " + message, color));
+}
+function getErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/config/upload-release.ts
+var MAX_PARALLEL_UPLOADS = 5;
+var REQUEST_TIMEOUT = 3e4;
+function getCollector(options) {
+  if (options.token === void 0 || options.token === "") {
+    log("Integration Token is not provided, release will not be sent", consoleColors.fgYellow);
+    return void 0;
+  }
+  const integrationId = getIntegrationId(options.token);
+  const endpoint = options.collectorEndpoint ?? (integrationId !== void 0 ? getDefaultCollectorEndpoint(integrationId) : void 0);
+  if (endpoint === void 0) {
+    log("Invalid Integration Token, release will not be sent", consoleColors.fgRed);
+    return void 0;
+  }
+  return {
+    endpoint,
+    token: options.token,
+    release: options.release,
+    timeout: REQUEST_TIMEOUT
+  };
+}
+async function uploadCommits(collector, repo, count) {
+  let commits;
+  try {
+    commits = await getCommits(repo, count);
+  } catch (_error) {
+    log("Commits are not sent: git history is not available. Pass `commits: false` to skip them", consoleColors.fgYellow);
+    return;
+  }
+  if (commits.length === 0) {
+    return;
+  }
+  try {
+    await sendCommits(collector, commits);
+    log(`Recent commits sent: ${commits.length}`, consoleColors.fgGreen);
+  } catch (error) {
+    log(`(\u2310\u25A0_\u25A0) Sending commits failed: ${getErrorMessage(error)}`, consoleColors.fgRed);
+  }
+}
+async function uploadSourceMaps(collector, distDir) {
+  const maps = await findClientSourceMaps(distDir);
+  if (maps.length === 0) {
+    log("No client source maps found. Make sure `productionBrowserSourceMaps` is not disabled in next.config", consoleColors.fgYellow);
+    return;
+  }
+  let sentCount = 0;
+  await mapConcurrently(maps, MAX_PARALLEL_UPLOADS, async (map) => {
+    try {
+      const content = prepareSourceMap(await readFile2(map.path, "utf8"), map.chunkUrl);
+      await sendSourceMap(collector, map.name, content);
+      sentCount += 1;
+    } catch (error) {
+      log(`(\u2310\u25A0_\u25A0) ${map.chunkUrl}.map \u2013 sending failed: ${getErrorMessage(error)}`, consoleColors.fgRed);
+    }
+  });
+  const color = sentCount === maps.length ? consoleColors.fgGreen : consoleColors.fgYellow;
+  log(`${sentCount} of ${maps.length} source maps sent for release "${collector.release}"`, color);
+}
+async function removeSourceMaps(distDir, stripSourceMappingUrls) {
+  const removedCount = await deleteClientSourceMaps(distDir);
+  if (removedCount > 0) {
+    log(`${removedCount} client source maps removed`);
+  }
+  if (stripSourceMappingUrls) {
+    await stripSourceMappingUrlComments(distDir);
+  }
+}
+async function uploadRelease(metadata, options) {
+  const startedAt = Date.now();
+  try {
+    const collector = getCollector(options);
+    if (collector === void 0) {
+      return;
+    }
+    try {
+      if (options.commits !== false) {
+        await uploadCommits(collector, options.commits.repo ?? metadata.projectDir, options.commits.number);
+      }
+      await uploadSourceMaps(collector, metadata.distDir);
+    } finally {
+      if (options.removeSourceMaps) {
+        await removeSourceMaps(metadata.distDir, options.stripSourceMappingUrls);
+      }
+    }
+    log(`Release "${collector.release}" processed in ${Date.now() - startedAt} ms`);
+  } catch (error) {
+    log(`(\u2310\u25A0_\u25A0) Release uploading failed: ${getErrorMessage(error)}`, consoleColors.fgRed);
+  }
+}
+
+// src/config/with-hawk-config.ts
+var MIN_NEXT_VERSION = "15.4.1";
+var DEFAULT_COMMITS_NUMBER = 5;
+var TOKEN_ENV_VARIABLES = ["HAWK_TOKEN", "NEXT_PUBLIC_HAWK_TOKEN"];
+function isVersionAtLeast(version, minVersion) {
+  const toNumbers = (value) => value.split("-")[0].split(".").map(Number);
+  const actual = toNumbers(version);
+  const min = toNumbers(minVersion);
+  for (const [i, minPart] of min.entries()) {
+    const part = actual[i] ?? 0;
+    if (part !== minPart) {
+      return part > minPart;
+    }
+  }
+  return true;
+}
+function getNextVersion(projectDir) {
+  try {
+    const requireFromProject = createRequire(path5.join(projectDir, "package.json"));
+    return requireFromProject("next/package.json").version;
+  } catch (_error) {
+    return void 0;
+  }
+}
+function getEnvToken() {
+  return TOKEN_ENV_VARIABLES.map((name) => process2.env[name]).find((value) => value !== void 0 && value !== "");
+}
+async function checkInstrumentationFiles(projectDir, pageExtensions) {
+  const missing = await findMissingInstrumentationFiles(projectDir, pageExtensions);
+  if (missing.length > 0) {
+    const files = missing.map((name) => `${name}.ts`).join(" and ");
+    log(`${files} not found, so errors are not caught. See https://github.com/codex-team/hawk.nextjs#error-tracking`, consoleColors.fgYellow);
+  }
+}
+function getCommitsOptions(commits = true) {
+  if (commits === false) {
+    return false;
+  }
+  const custom = commits === true ? {} : commits;
+  return {
+    repo: custom.repo,
+    number: custom.number ?? DEFAULT_COMMITS_NUMBER
+  };
+}
+function applyHawkConfig(config, options) {
+  const projectDir = process2.cwd();
+  const release = resolveRelease(options.release, projectDir);
+  process2.env[RELEASE_ENV_VARIABLE] = release;
+  const result = {
+    ...config,
+    env: {
+      ...config.env,
+      [RELEASE_ENV_VARIABLE]: release
+    }
+  };
+  const nextVersion = getNextVersion(projectDir);
+  if (nextVersion !== void 0 && !isVersionAtLeast(nextVersion, MIN_NEXT_VERSION)) {
+    log(`Next.js ${nextVersion} is not supported, update it to ${MIN_NEXT_VERSION} or newer to send releases`, consoleColors.fgYellow);
+    return result;
+  }
+  const token = options.token ?? getEnvToken();
+  const hasToken = token !== void 0 && token !== "";
+  const canUpload = hasToken && (options.collectorEndpoint !== void 0 || getIntegrationId(token) !== void 0);
+  if (canUpload && config.productionBrowserSourceMaps === void 0) {
+    result.productionBrowserSourceMaps = true;
+  }
+  const uploadOptions = {
+    token,
+    release,
+    collectorEndpoint: options.collectorEndpoint,
+    removeSourceMaps: options.removeSourceMaps ?? true,
+    stripSourceMappingUrls: config.experimental?.sri === void 0,
+    commits: getCommitsOptions(options.commits)
+  };
+  const userHook = config.compiler?.runAfterProductionCompile;
+  result.compiler = {
+    ...config.compiler,
+    runAfterProductionCompile: async (metadata) => {
+      if (userHook !== void 0) {
+        await userHook(metadata);
+      }
+      await checkInstrumentationFiles(metadata.projectDir, config.pageExtensions);
+      await uploadRelease(metadata, uploadOptions);
+    }
+  };
+  return result;
+}
+function withHawkConfig(nextConfig, options = {}) {
+  if (typeof nextConfig === "function") {
+    return async (phase, context) => applyHawkConfig(await nextConfig(phase, context), options);
+  }
+  return applyHawkConfig(nextConfig, options);
+}
+export {
+  withHawkConfig
+};