@vercel/build-utils 13.10.0 → 13.12.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @vercel/build-utils
 
+## 13.12.0
+
+### Minor Changes
+
+- Add hash utilities (`streamToDigestAsync`, `sha256`, `md5`) and build result helpers (`getBuildResultMetadata`, `getLambdaByOutputPath`, `isRouteMiddleware`, `getPrerenderChain`, `streamWithExtendedPayload`) for shared use. ([#15726](https://github.com/vercel/vercel/pull/15726))
+
+## 13.11.0
+
+### Minor Changes
+
+- Add `process-serverless` utilities: `getLambdaEnvironment`, `getLambdaPreloadScripts`, `getLambdaSupportsStreaming`, and `getEncryptedEnv`. ([#15712](https://github.com/vercel/vercel/pull/15712))
+
 ## 13.10.0
 
 ### Minor Changes

package/dist/collect-build-result/get-build-result-metadata.d.ts

@@ -0,0 +1,33 @@
+import type { Route } from '@vercel/routing-utils';
+import type { EdgeFunction } from '../edge-function';
+import type { File } from '../types';
+import type { Lambda } from '../lambda';
+import type { Prerender } from '../prerender';
+export interface BuildResultMetadata {
+    middleware: Map<string, MiddlewareMeta>;
+    ppr: Map<string, boolean>;
+}
+/**
+ * Extract metadata about the build result that depend on the relationship
+ * between components in the build output. This data is later used to map to
+ * the infrastructure that we need to create.
+ */
+export declare function getBuildResultMetadata(params: {
+    buildOutputMap: Record<string, EdgeFunction | Lambda | Prerender | File>;
+    routes: Route[];
+}): BuildResultMetadata;
+type MiddlewareMeta = {
+    type: 'middleware';
+    middlewarePath: string;
+    outputPath: string;
+    match: Set<string>;
+    edgeFunction: EdgeFunction;
+    index: number;
+} | {
+    type: 'middleware-lambda';
+    middlewarePath: string;
+    outputPath: string;
+    match: Set<string>;
+    index: number;
+};
+export {};

package/dist/collect-build-result/get-build-result-metadata.js

@@ -0,0 +1,99 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var get_build_result_metadata_exports = {};
+__export(get_build_result_metadata_exports, {
+  getBuildResultMetadata: () => getBuildResultMetadata
+});
+module.exports = __toCommonJS(get_build_result_metadata_exports);
+var import_errors = require("../errors");
+var import_get_lambda_by_output_path = require("./get-lambda-by-output-path");
+var import_get_prerender_chain = require("./get-prerender-chain");
+var import_is_route_middleware = require("./is-route-middleware");
+function getBuildResultMetadata(params) {
+  return {
+    middleware: getMiddlewareMetadata(params),
+    ppr: new Map(
+      Object.entries(params.buildOutputMap).flatMap(([_outputPath, output]) => {
+        if (output.type === "Prerender") {
+          const chain = (0, import_get_prerender_chain.getPrerenderChain)(output);
+          if (chain) {
+            const maybeLambda = (0, import_get_lambda_by_output_path.getLambdaByOutputPath)({
+              buildOutputMap: params.buildOutputMap,
+              outputPath: chain.outputPath
+            });
+            if (maybeLambda) {
+              return [[chain.outputPath, true]];
+            }
+          }
+        }
+        return [];
+      })
+    )
+  };
+}
+function getMiddlewareMetadata(params) {
+  const deduped = new Map(
+    params.routes.filter(import_is_route_middleware.isRouteMiddleware).map(
+      (route) => toMiddlewareTuple({
+        buildOutputMap: params.buildOutputMap,
+        middlewarePath: route.middlewarePath
+      })
+    )
+  );
+  return new Map(
+    Array.from(deduped, ([outputPath, metadata], index) => [
+      outputPath,
+      { ...metadata, index }
+    ])
+  );
+}
+function toMiddlewareTuple(params) {
+  const keys = [
+    params.middlewarePath,
+    params.middlewarePath.replace(/^\//, "")
+  ];
+  const [outputPath, output] = Object.entries(params.buildOutputMap).find(
+    (entry) => keys.includes(entry[0]) && (entry[1].type === "EdgeFunction" || entry[1].type === "Lambda")
+  ) ?? [];
+  if (!outputPath || !output) {
+    throw new import_errors.NowBuildError({
+      message: `Mapping ${params.middlewarePath} not found. Maybe you provided a wrong middlewarePath?`,
+      code: "middleware_path_not_found"
+    });
+  }
+  return [
+    outputPath,
+    output.type === "EdgeFunction" ? {
+      edgeFunction: output,
+      match: new Set(keys),
+      middlewarePath: params.middlewarePath,
+      outputPath,
+      type: "middleware"
+    } : {
+      match: new Set(keys),
+      middlewarePath: params.middlewarePath,
+      outputPath,
+      type: "middleware-lambda"
+    }
+  ];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getBuildResultMetadata
+});

package/dist/collect-build-result/get-lambda-by-output-path.d.ts

@@ -0,0 +1,13 @@
+import type { EdgeFunction } from '../edge-function';
+import type { File } from '../types';
+import type { Lambda } from '../lambda';
+import type { Prerender } from '../prerender';
+/**
+ * A Prerender can hold references to a Lambda or another Prerender when
+ * using PPR. This function retrieves the Lambda or Prerender from the
+ * build output map ensuring its type.
+ */
+export declare function getLambdaByOutputPath(params: {
+    buildOutputMap: Record<string, EdgeFunction | Lambda | Prerender | File>;
+    outputPath: string;
+}): Lambda | undefined;

package/dist/collect-build-result/get-lambda-by-output-path.js

@@ -0,0 +1,31 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var get_lambda_by_output_path_exports = {};
+__export(get_lambda_by_output_path_exports, {
+  getLambdaByOutputPath: () => getLambdaByOutputPath
+});
+module.exports = __toCommonJS(get_lambda_by_output_path_exports);
+function getLambdaByOutputPath(params) {
+  const output = params.buildOutputMap[params.outputPath];
+  return output?.type === "Lambda" ? output : output?.type === "Prerender" ? output.lambda : void 0;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getLambdaByOutputPath
+});

package/dist/collect-build-result/get-prerender-chain.d.ts

@@ -0,0 +1,8 @@
+import type { Chain } from '../types';
+import type { Prerender } from '../prerender';
+/**
+ * The Prerender chain can be defined as a `chain` property or as a flag
+ * `experimentalStreamingLambdaPath`. This function normalizes the chain
+ * to a single structure.
+ */
+export declare function getPrerenderChain(prerender: Prerender): Chain | undefined;

package/dist/collect-build-result/get-prerender-chain.js

@@ -0,0 +1,44 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var get_prerender_chain_exports = {};
+__export(get_prerender_chain_exports, {
+  getPrerenderChain: () => getPrerenderChain
+});
+module.exports = __toCommonJS(get_prerender_chain_exports);
+function getPrerenderChain(prerender) {
+  if (prerender.chain) {
+    return {
+      outputPath: prerender.chain.outputPath,
+      headers: prerender.chain.headers
+    };
+  }
+  if (prerender.experimentalStreamingLambdaPath) {
+    return {
+      outputPath: prerender.experimentalStreamingLambdaPath,
+      headers: {
+        "x-matched-path": prerender.experimentalStreamingLambdaPath
+      }
+    };
+  }
+  return void 0;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getPrerenderChain
+});

package/dist/collect-build-result/is-route-middleware.d.ts

@@ -0,0 +1,4 @@
+import type { Route } from '@vercel/routing-utils';
+export declare function isRouteMiddleware(route: Route): route is Route & {
+    middlewarePath: string;
+};

package/dist/collect-build-result/is-route-middleware.js

@@ -0,0 +1,30 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var is_route_middleware_exports = {};
+__export(is_route_middleware_exports, {
+  isRouteMiddleware: () => isRouteMiddleware
+});
+module.exports = __toCommonJS(is_route_middleware_exports);
+function isRouteMiddleware(route) {
+  return "middlewarePath" in route && typeof route.middlewarePath === "string";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isRouteMiddleware
+});

package/dist/collect-build-result/stream-with-extended-payload.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="node" />
+export interface ExtendedBodyData {
+    prefix: string;
+    suffix: string;
+}
+export declare function streamWithExtendedPayload(stream: NodeJS.ReadableStream, data?: ExtendedBodyData): NodeJS.ReadableStream;

package/dist/collect-build-result/stream-with-extended-payload.js

@@ -0,0 +1,49 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var stream_with_extended_payload_exports = {};
+__export(stream_with_extended_payload_exports, {
+  streamWithExtendedPayload: () => streamWithExtendedPayload
+});
+module.exports = __toCommonJS(stream_with_extended_payload_exports);
+var import_stream = require("stream");
+function streamWithExtendedPayload(stream, data) {
+  return data ? new MultipartContentStream(stream, data) : stream;
+}
+class MultipartContentStream extends import_stream.Readable {
+  constructor(stream, data) {
+    super();
+    stream.on("error", (err) => {
+      this.emit("error", err);
+    });
+    stream.on("end", () => {
+      this.push(data.suffix);
+      this.push(null);
+    });
+    this.push(data.prefix);
+    stream.on("data", (chunk) => {
+      this.push(chunk);
+    });
+  }
+  _read() {
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  streamWithExtendedPayload
+});

package/dist/fs/stream-to-digest-async.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="node" />
+/// <reference types="node" />
+export interface FileDigest {
+    md5: string;
+    sha256: string;
+    size: number;
+}
+export declare function streamToDigestAsync(stream: NodeJS.ReadableStream): Promise<FileDigest>;
+export declare function sha256(value: any): string;
+export declare function md5(value: Buffer): string;

package/dist/fs/stream-to-digest-async.js

@@ -0,0 +1,62 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var stream_to_digest_async_exports = {};
+__export(stream_to_digest_async_exports, {
+  md5: () => md5,
+  sha256: () => sha256,
+  streamToDigestAsync: () => streamToDigestAsync
+});
+module.exports = __toCommonJS(stream_to_digest_async_exports);
+var import_crypto = require("crypto");
+async function streamToDigestAsync(stream) {
+  return await new Promise((resolve, reject) => {
+    stream.once("error", reject);
+    let count = 0;
+    const sha2562 = (0, import_crypto.createHash)("sha256");
+    const md52 = (0, import_crypto.createHash)("md5");
+    stream.on("end", () => {
+      const res = {
+        sha256: sha2562.digest("hex"),
+        md5: md52.digest("hex"),
+        size: count
+      };
+      resolve(res);
+    });
+    stream.on("readable", () => {
+      let chunk;
+      while (null !== (chunk = stream.read())) {
+        md52.update(chunk);
+        sha2562.update(chunk);
+        count += chunk.length;
+      }
+    });
+  });
+}
+function sha256(value) {
+  return (0, import_crypto.createHash)("sha256").update(value).digest("hex");
+}
+function md5(value) {
+  return (0, import_crypto.createHash)("md5").update(value).digest("hex");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  md5,
+  sha256,
+  streamToDigestAsync
+});

package/dist/index.d.ts

@@ -36,3 +36,13 @@ export { defaultCachePathGlob } from './default-cache-path-glob';
 export { generateNodeBuilderFunctions } from './generate-node-builder-functions';
 export { BACKEND_FRAMEWORKS, BACKEND_BUILDERS, UNIFIED_BACKEND_BUILDER, BackendFramework, isBackendFramework, isNodeBackendFramework, isBackendBuilder, isExperimentalBackendsEnabled, isExperimentalBackendsWithoutIntrospectionEnabled, shouldUseExperimentalBackends, PYTHON_FRAMEWORKS, PythonFramework, isPythonFramework, } from './framework-helpers';
 export * from './python';
+export { getEncryptedEnv, type EncryptedEnvFile, } from './process-serverless/get-encrypted-env-file';
+export { getLambdaEnvironment } from './process-serverless/get-lambda-environment';
+export { getLambdaPreloadScripts, type BytecodeCachingOptions, } from './process-serverless/get-lambda-preload-scripts';
+export { getLambdaSupportsStreaming, type SupportsStreamingResult, } from './process-serverless/get-lambda-supports-streaming';
+export { streamToDigestAsync, sha256, md5, type FileDigest, } from './fs/stream-to-digest-async';
+export { getBuildResultMetadata, type BuildResultMetadata, } from './collect-build-result/get-build-result-metadata';
+export { getLambdaByOutputPath } from './collect-build-result/get-lambda-by-output-path';
+export { isRouteMiddleware } from './collect-build-result/is-route-middleware';
+export { getPrerenderChain } from './collect-build-result/get-prerender-chain';
+export { streamWithExtendedPayload, type ExtendedBodyData, } from './collect-build-result/stream-with-extended-payload';