chore: make all paths explicit using the process.cwd() (#47)

Author: lukasholzer

Diff for: src/build/constants.ts

@@ -1,17 +1,16 @@
-import { resolve } from 'node:path'
+import { join } from 'node:path'
 import { fileURLToPath } from 'node:url'
 
 export const MODULE_DIR = fileURLToPath(new URL('.', import.meta.url))
-export const PLUGIN_DIR = resolve(`${MODULE_DIR}../..`)
-export const WORKING_DIR = process.cwd()
+export const PLUGIN_DIR = join(MODULE_DIR, '../..')
 
-export const BUILD_DIR = `${WORKING_DIR}/.netlify`
-export const REL_BUILD_DIR = '.netlify'
+/** A relative path where we store the build output */
+export const BUILD_DIR = '.netlify'
 
-export const SERVER_FUNCTIONS_DIR = `${BUILD_DIR}/functions-internal`
+export const SERVER_FUNCTIONS_DIR = join(BUILD_DIR, 'functions-internal')
 export const SERVER_HANDLER_NAME = '___netlify-server-handler'
-export const SERVER_HANDLER_DIR = `${SERVER_FUNCTIONS_DIR}/${SERVER_HANDLER_NAME}`
+export const SERVER_HANDLER_DIR = join(SERVER_FUNCTIONS_DIR, SERVER_HANDLER_NAME)
 
-export const EDGE_FUNCTIONS_DIR = `${BUILD_DIR}/edge-functions`
+export const EDGE_FUNCTIONS_DIR = join(BUILD_DIR, 'edge-functions')
 export const EDGE_HANDLER_NAME = '___netlify-edge-handler'
-export const EDGE_HANDLER_DIR = `${EDGE_FUNCTIONS_DIR}/${EDGE_HANDLER_NAME}`
+export const EDGE_HANDLER_DIR = join(EDGE_FUNCTIONS_DIR, EDGE_HANDLER_NAME)

Diff for: src/build/content/prerendered.ts

@@ -6,7 +6,7 @@ import { join } from 'node:path'
 import { cpus } from 'os'
 import pLimit from 'p-limit'
 import { parse, ParsedPath } from 'path'
-import { REL_BUILD_DIR } from '../constants.js'
+import { BUILD_DIR } from '../constants.js'
 
 export type CacheEntry = {
   key: string
@@ -145,7 +145,7 @@ export const uploadPrerenderedContent = async ({
 
   // read prerendered content and build JSON key/values for the blob store
   const entries = await Promise.allSettled(
-    await buildPrerenderedContentEntries(join(process.cwd(), REL_BUILD_DIR, '.next')),
+    await buildPrerenderedContentEntries(join(process.cwd(), BUILD_DIR, '.next')),
   )
   entries.forEach((result) => {
     if (result.status === 'rejected') {

Diff for: src/build/content/static.ts

@@ -3,7 +3,7 @@ import { globby } from 'globby'
 import { existsSync } from 'node:fs'
 import { copyFile, cp, mkdir } from 'node:fs/promises'
 import { ParsedPath, dirname, join, parse } from 'node:path'
-import { REL_BUILD_DIR, WORKING_DIR } from '../constants.js'
+import { BUILD_DIR } from '../constants.js'
 
 /**
  * Copy static pages (HTML without associated JSON data)
@@ -36,7 +36,7 @@ const copyStaticAssets = async ({
   PUBLISH_DIR,
 }: Pick<NetlifyPluginConstants, 'PUBLISH_DIR'>): Promise<void> => {
   try {
-    const src = join(process.cwd(), REL_BUILD_DIR, '.next/static')
+    const src = join(process.cwd(), BUILD_DIR, '.next/static')
     const dist = join(PUBLISH_DIR, '_next/static')
     await mkdir(dist, { recursive: true })
     cp(src, dist, { recursive: true, force: true })
@@ -51,7 +51,7 @@ const copyStaticAssets = async ({
 const copyPublicAssets = async ({
   PUBLISH_DIR,
 }: Pick<NetlifyPluginConstants, 'PUBLISH_DIR'>): Promise<void> => {
-  const src = join(WORKING_DIR, 'public')
+  const src = join(process.cwd(), 'public')
   const dist = join(PUBLISH_DIR, 'public')
   if (!existsSync(src)) {
     return
@@ -66,7 +66,7 @@ const copyPublicAssets = async ({
  */
 export const copyStaticContent = async ({ PUBLISH_DIR }: NetlifyPluginConstants): Promise<void> => {
   await Promise.all([
-    copyStaticPages(join(process.cwd(), REL_BUILD_DIR, '.next'), PUBLISH_DIR),
+    copyStaticPages(join(process.cwd(), BUILD_DIR, '.next'), PUBLISH_DIR),
     copyStaticAssets({ PUBLISH_DIR }),
     copyPublicAssets({ PUBLISH_DIR }),
   ])

Diff for: src/build/functions/edge.ts

@@ -1,11 +1,12 @@
 import { mkdir, rm } from 'node:fs/promises'
+import { join } from 'node:path'
 import { EDGE_HANDLER_DIR } from '../constants.js'
 
 /**
  * Create a Netlify edge function to run the Next.js server
  */
 export const createEdgeHandler = async () => {
   // reset the handler directory
-  await rm(EDGE_HANDLER_DIR, { recursive: true, force: true })
-  await mkdir(EDGE_HANDLER_DIR, { recursive: true })
+  await rm(join(process.cwd(), EDGE_HANDLER_DIR), { recursive: true, force: true })
+  await mkdir(join(process.cwd(), EDGE_HANDLER_DIR), { recursive: true })
 }

Diff for: src/build/functions/server.ts

@@ -1,6 +1,6 @@
 import { nodeFileTrace } from '@vercel/nft'
 import { writeFile, rm, mkdir, cp } from 'fs/promises'
-import { REL_BUILD_DIR, PLUGIN_DIR, SERVER_HANDLER_DIR, SERVER_HANDLER_NAME } from '../constants.js'
+import { BUILD_DIR, PLUGIN_DIR, SERVER_HANDLER_DIR, SERVER_HANDLER_NAME } from '../constants.js'
 import { copyServerContent } from '../content/server.js'
 import { join } from 'node:path'
 import { readFileSync } from 'fs'
@@ -12,8 +12,8 @@ const pkg = JSON.parse(readFileSync(join(PLUGIN_DIR, 'package.json'), 'utf-8'))
  */
 export const createServerHandler = async () => {
   // reset the handler directory
-  await rm(SERVER_HANDLER_DIR, { force: true, recursive: true })
-  await mkdir(SERVER_HANDLER_DIR, { recursive: true })
+  await rm(join(process.cwd(), SERVER_HANDLER_DIR), { force: true, recursive: true })
+  await mkdir(join(process.cwd(), SERVER_HANDLER_DIR), { recursive: true })
 
   // trace the handler dependencies
   const { fileList } = await nodeFileTrace(
@@ -27,24 +27,26 @@ export const createServerHandler = async () => {
   // copy the handler dependencies
   await Promise.all(
     [...fileList].map((path) =>
-      cp(join(PLUGIN_DIR, path), join(SERVER_HANDLER_DIR, path), { recursive: true }),
+      cp(join(PLUGIN_DIR, path), join(process.cwd(), SERVER_HANDLER_DIR, path), {
+        recursive: true,
+      }),
     ),
   )
 
   // copy the next.js standalone build output to the handler directory
   await copyServerContent(
-    join(process.cwd(), REL_BUILD_DIR, '.next/standalone/.next'),
-    join(SERVER_HANDLER_DIR, '.next'),
+    join(process.cwd(), BUILD_DIR, '.next/standalone/.next'),
+    join(process.cwd(), SERVER_HANDLER_DIR, '.next'),
   )
   await cp(
-    join(process.cwd(), REL_BUILD_DIR, '.next/standalone/node_modules'),
-    join(SERVER_HANDLER_DIR, 'node_modules'),
+    join(process.cwd(), BUILD_DIR, '.next/standalone/node_modules'),
+    join(process.cwd(), SERVER_HANDLER_DIR, 'node_modules'),
     { recursive: true },
   )
 
   // create the handler metadata file
   await writeFile(
-    join(SERVER_HANDLER_DIR, `${SERVER_HANDLER_NAME}.json`),
+    join(process.cwd(), SERVER_HANDLER_DIR, `${SERVER_HANDLER_NAME}.json`),
     JSON.stringify({
       config: {
         name: 'Next.js Server Handler',
@@ -57,19 +59,22 @@ export const createServerHandler = async () => {
           '.next/**',
           'node_modules/**',
         ],
-        includedFilesBasePath: SERVER_HANDLER_DIR,
+        includedFilesBasePath: join(process.cwd(), SERVER_HANDLER_DIR),
       },
       version: 1,
     }),
     'utf-8',
   )
 
   // configure ESM
-  await writeFile(join(SERVER_HANDLER_DIR, 'package.json'), JSON.stringify({ type: 'module' }))
+  await writeFile(
+    join(process.cwd(), SERVER_HANDLER_DIR, 'package.json'),
+    JSON.stringify({ type: 'module' }),
+  )
 
   // write the root handler file
   await writeFile(
-    join(SERVER_HANDLER_DIR, `${SERVER_HANDLER_NAME}.js`),
+    join(process.cwd(), SERVER_HANDLER_DIR, `${SERVER_HANDLER_NAME}.js`),
     `import handler from './dist/run/handlers/server.js';export default handler;export const config = {path:'/*'}`,
   )
 }

Diff for: src/build/move-build-output.ts

@@ -2,7 +2,7 @@ import { NetlifyPluginConstants, NetlifyPluginUtils } from '@netlify/build'
 import { existsSync } from 'node:fs'
 import { mkdir, rename, rm } from 'node:fs/promises'
 import { join } from 'node:path'
-import { REL_BUILD_DIR } from './constants.js'
+import { BUILD_DIR } from './constants.js'
 
 /**
  * Move the Next.js build output from the publish dir to a temp dir
@@ -17,7 +17,7 @@ export const moveBuildOutput = async (
     )
   }
 
-  const tempDir = join(process.cwd(), REL_BUILD_DIR, '.next')
+  const tempDir = join(process.cwd(), BUILD_DIR, '.next')
 
   try {
     // cleanup any existing directory

Diff for: tests/utils/fixture.ts

@@ -14,7 +14,7 @@ import { cp, mkdtemp, rm } from 'node:fs/promises'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
 import { fileURLToPath } from 'node:url'
-import { SERVER_HANDLER_NAME } from '../../src/build/constants.js'
+import { SERVER_FUNCTIONS_DIR, SERVER_HANDLER_NAME } from '../../src/build/constants.js'
 import { streamToString } from './stream-to-string.js'
 
 export interface FixtureTestContext extends TestContext {
@@ -106,20 +106,18 @@ export async function runPlugin(
     } as NetlifyPluginUtils,
   } as unknown as NetlifyPluginOptions)
 
-  // We need to do a dynamic import as we mock the `process.cwd()` inside the createFixture function
-  // If we import it before calling that it will resolve to the actual process working directory instead of the mocked one
-  const { SERVER_FUNCTIONS_DIR } = await import('../../src/build/constants.js')
+  const internalSrcFolder = join(ctx.cwd, SERVER_FUNCTIONS_DIR)
 
   // create zip location in a new temp folder to avoid leaking node_modules through nodes resolve algorithm
   // that always looks up a parent directory for node_modules
   ctx.functionDist = await mkdtemp(join(tmpdir(), 'netlify-next-runtime-dist'))
   // bundle the function to get the bootstrap layer and all the important parts
-  await zipFunctions(SERVER_FUNCTIONS_DIR, ctx.functionDist, {
+  await zipFunctions([internalSrcFolder], ctx.functionDist, {
     basePath: ctx.cwd,
     manifest: join(ctx.functionDist, 'manifest.json'),
     repositoryRoot: ctx.cwd,
-    configFileDirectories: [SERVER_FUNCTIONS_DIR],
-    internalSrcFolder: SERVER_FUNCTIONS_DIR,
+    configFileDirectories: [internalSrcFolder],
+    internalSrcFolder,
     archiveFormat: 'none',
   })
 }