@vercel/build-utils 4.0.0 → 4.1.1-canary.0

package/dist/detect-builders.d.ts

@@ -7,7 +7,7 @@ interface ErrorResponse {
     link?: string;
 }
 interface Options {
-    tag?: 'canary' | 'latest' | string;
+    tag?: string;
     functions?: BuilderFunctions;
     ignoreBuildScript?: boolean;
     projectSettings?: ProjectSettings;

package/dist/detect-builders.js

@@ -187,7 +187,7 @@ async function detectBuilders(files, pkg, options = {}) {
             // and package.json can be served as static files
             frontendBuilder = {
                 use: '@vercel/static',
-                src: '!{api/**,package.json}',
+                src: '!{api/**,package.json,middleware.[jt]s}',
                 config: {
                     zeroConfig: true,
                 },
@@ -237,7 +237,13 @@ async function detectBuilders(files, pkg, options = {}) {
 }
 exports.detectBuilders = detectBuilders;
 function maybeGetApiBuilder(fileName, apiMatches, options) {
-    if (!fileName.startsWith('api/')) {
+    const middleware = fileName === 'middleware.js' || fileName === 'middleware.ts';
+    // Root-level Middleware file is handled by `@vercel/next`, so don't
+    // schedule a separate Builder when "nextjs" framework is selected
+    if (middleware && options.projectSettings?.framework === 'nextjs') {
+        return null;
+    }
+    if (!(fileName.startsWith('api/') || middleware)) {
         return null;
     }
     if (fileName.includes('/.')) {
@@ -256,11 +262,14 @@ function maybeGetApiBuilder(fileName, apiMatches, options) {
         return src === fileName || minimatch_1.default(fileName, src);
     });
     const { fnPattern, func } = getFunction(fileName, options);
-    const use = (func && func.runtime) || (match && match.use);
+    const use = func?.runtime || match?.use;
     if (!use) {
         return null;
     }
     const config = { zeroConfig: true };
+    if (middleware) {
+        config.middleware = true;
+    }
     if (fnPattern && func) {
         config.functions = { [fnPattern]: func };
         if (func.includeFiles) {
@@ -290,6 +299,7 @@ function getFunction(fileName, { functions = {} }) {
 function getApiMatches() {
     const config = { zeroConfig: true };
     return [
+        { src: 'middleware.[jt]s', use: `@vercel/node`, config },
         { src: 'api/**/*.js', use: `@vercel/node`, config },
         { src: 'api/**/*.mjs', use: `@vercel/node`, config },
         { src: 'api/**/*.ts', use: `@vercel/node`, config },

package/dist/fs/get-glob-fs.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="node" />
+import fs from 'fs';
+import { DetectorFilesystem } from '../detectors/filesystem';
+declare type GlobFs = typeof fs;
+export declare function getGlobFs(_fs: DetectorFilesystem): GlobFs;
+export {};

package/dist/fs/get-glob-fs.js

@@ -0,0 +1,71 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGlobFs = void 0;
+const fs_1 = __importDefault(require("fs"));
+function normalizePath(path) {
+    // on windows, this will return a path like
+    // D:/c/package.json
+    // since we abstract the filesystem, we need to remove windows specific info from the path
+    // and let the FS decide how to process the path
+    // D:/c/package.json => /c/package.json
+    return path.replace(/^[a-zA-Z]:/, '');
+}
+function getGlobFs(_fs) {
+    const readdir = (path, callback) => {
+        _fs
+            .readdir(normalizePath(String(path)))
+            .then(stats => callback(null, stats.map(stat => stat.name)))
+            .catch(err => callback(err, []));
+    };
+    const stat = (path, callback) => {
+        _fs
+            .isFile(normalizePath(String(path)))
+            .then(isPathAFile => {
+            callback(null, {
+                ino: 0,
+                mode: 0,
+                nlink: 0,
+                uid: 0,
+                gid: 0,
+                rdev: 0,
+                size: 0,
+                blksize: 0,
+                blocks: 0,
+                atimeMs: 0,
+                mtimeMs: 0,
+                ctimeMs: 0,
+                birthtimeMs: 0,
+                atime: new Date(),
+                mtime: new Date(),
+                ctime: new Date(),
+                birthtime: new Date(),
+                dev: 0,
+                isBlockDevice: () => false,
+                isCharacterDevice: () => false,
+                isDirectory: () => !isPathAFile,
+                isFIFO: () => false,
+                isFile: () => isPathAFile,
+                isSocket: () => false,
+                isSymbolicLink: () => false,
+            });
+        })
+            .catch(err => callback(err, null));
+    };
+    return new Proxy(fs_1.default, {
+        get(_target, prop) {
+            switch (prop) {
+                case 'readdir':
+                    return readdir;
+                case 'lstat':
+                case 'stat':
+                    return stat;
+                default:
+                    throw new Error('Not Implemented');
+            }
+        },
+    });
+}
+exports.getGlobFs = getGlobFs;

package/dist/get-project-paths.d.ts

@@ -0,0 +1,9 @@
+import { DetectorFilesystem } from './detectors/filesystem';
+export interface GetProjectPathsOptions {
+    fs: DetectorFilesystem;
+    path?: string;
+    skipPaths?: string[];
+    depth?: number;
+}
+export declare type ProjectPath = string;
+export declare const getProjectPaths: ({ fs, path, skipPaths, depth, }: GetProjectPathsOptions) => Promise<ProjectPath[]>;

package/dist/get-project-paths.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProjectPaths = void 0;
+const detect_framework_1 = require("./detect-framework");
+const frameworks_1 = __importDefault(require("@vercel/frameworks"));
+const MAX_DEPTH_TRAVERSE = 3;
+const getProjectPaths = async ({ fs, path, skipPaths, depth = MAX_DEPTH_TRAVERSE, }) => {
+    if (depth === 0)
+        return [];
+    const allPaths = [];
+    const topPath = path ?? './';
+    if (path && skipPaths?.includes(path)) {
+        return allPaths;
+    }
+    const framework = await detect_framework_1.detectFramework({
+        fs: fs.chdir(topPath),
+        frameworkList: frameworks_1.default,
+    });
+    if (framework !== null)
+        allPaths.push(topPath);
+    if (depth > 1) {
+        const directoryContents = await fs.readdir(topPath);
+        const childDirectories = directoryContents.filter(stat => stat.type === 'dir' && !skipPaths?.includes(stat.path));
+        const paths = (await Promise.all(childDirectories.map(({ path }) => {
+            return exports.getProjectPaths({
+                fs,
+                path,
+                depth: depth - 1,
+                skipPaths,
+            });
+        }))).flat();
+        return [...paths, ...allPaths];
+    }
+    return allPaths;
+};
+exports.getProjectPaths = getProjectPaths;

package/dist/index.d.ts

@@ -19,6 +19,7 @@ export { EdgeFunction } from './edge-function';
 export { detectBuilders, detectOutputDirectory, detectApiDirectory, detectApiExtensions, } from './detect-builders';
 export { detectFileSystemAPI } from './detect-file-system-api';
 export { detectFramework } from './detect-framework';
+export { getProjectPaths } from './get-project-paths';
 export { DetectorFilesystem } from './detectors/filesystem';
 export { readConfigFile } from './fs/read-config-file';
 export { normalizePath } from './fs/normalize-path';
@@ -32,5 +33,6 @@ export * from './errors';
 export declare const isOfficialRuntime: (desired: string, name?: string | undefined) => boolean;
 export declare const isStaticRuntime: (name?: string | undefined) => boolean;
 export { workspaceManagers } from './workspaces/workspace-managers';
-export { getWorkspaces } from './workspaces/get-workspaces';
+export { getWorkspaces, GetWorkspaceOptions, Workspace, WorkspaceType, } from './workspaces/get-workspaces';
+export { getWorkspacePackagePaths, GetWorkspacePackagePathsOptions, } from './workspaces/get-workspace-package-paths';
 export { monorepoManagers } from './monorepos/monorepo-managers';