feat: deploy standalone server

src/utils/deploy/deploy-site.ts

@@ -106,7 +106,7 @@ export const deploySite = async (
   const dbMigrationsDistPath = await getDbMigrationsDistPathIfExists(workingDir)
   const [
     { files: staticFiles, filesShaMap: staticShaMap },
-    { fnConfig, fnShaMap, functionSchedules, functions, functionsWithNativeModules },
+    { fnConfig, fnShaMap, functionSchedules, functions, functionsWithNativeModules, server, serverShaMap },
     configFile,
     { edgeFunctions, edgeFnShaMap },
   ] = await Promise.all([
@@ -188,6 +188,7 @@ For more information, visit https://ntl.fyi/cli-native-modules.`)
       files,
       functions,
       edge_functions: edgeFunctions,
+      server,
       function_schedules: functionSchedules,
       functions_config: fnConfig,
       async: Object.keys(files).length > syncFileLimit,
@@ -208,7 +209,12 @@ For more information, visit https://ntl.fyi/cli-native-modules.`)
 
   if (deployParams.body.async) deploy = await waitForDiff(api, deploy.id, siteId, deployTimeout)
 
-  const { required: requiredFiles, required_functions: requiredFns, required_edge_functions: requiredEdgeFns } = deploy
+  const {
+    required: requiredFiles,
+    required_functions: requiredFns,
+    required_edge_functions: requiredEdgeFns,
+    required_server: requiredServer,
+  } = deploy
 
   statusCb({
     type: 'create-deploy',
@@ -221,7 +227,8 @@ For more information, visit https://ntl.fyi/cli-native-modules.`)
   const filesUploadList = getUploadList(requiredFiles, filesShaMap)
   const functionsUploadList = getUploadList(requiredFns, fnShaMap)
   const edgeFunctionsUploadList = getUploadList(requiredEdgeFns, edgeFnShaMap)
-  const uploadList = [...filesUploadList, ...functionsUploadList, ...edgeFunctionsUploadList]
+  const serverUploadList = getUploadList(requiredServer, serverShaMap)
+  const uploadList = [...filesUploadList, ...functionsUploadList, ...edgeFunctionsUploadList, ...serverUploadList]
 
   await uploadFiles(api, deployId, uploadList, { concurrentUpload, statusCb, maxRetry })
 

src/utils/deploy/hash-fns.ts

@@ -14,6 +14,11 @@ import { hasherCtor, manifestCollectorCtor } from './hasher-segments.js'
 // Maximum age of functions manifest (2 minutes).
 const MANIFEST_FILE_TTL = 12e4
 
+interface ServerBundle {
+  path: string
+  region?: string
+}
+
 const getFunctionZips = async ({
   command,
   directories,
@@ -32,7 +37,7 @@ const getFunctionZips = async ({
   skipFunctionsCache?: boolean | undefined
   statusCb: $TSFixMe
   tmpDir: $TSFixMe
-}): Promise<(FunctionResult & { buildData?: unknown })[]> => {
+}): Promise<{ functions: (FunctionResult & { buildData?: unknown })[]; server?: ServerBundle }> => {
   statusCb({
     type: 'functions-manifest',
     msg: 'Looking for a functions cache...',
@@ -41,9 +46,11 @@ const getFunctionZips = async ({
 
   if (manifestPath) {
     try {
-      // read manifest.json file
-      // @ts-expect-error TS(2345) FIXME: Argument of type 'Buffer' is not assignable to par... Remove this comment to see the full error message
-      const { functions, timestamp } = JSON.parse(await readFile(manifestPath))
+      const { functions, server, timestamp } = JSON.parse(await readFile(manifestPath, 'utf-8')) as {
+        functions: (FunctionResult & { buildData?: unknown })[]
+        server?: ServerBundle
+        timestamp: number
+      }
       const manifestAge = Date.now() - timestamp
 
       if (manifestAge > MANIFEST_FILE_TTL) {
@@ -56,7 +63,7 @@ const getFunctionZips = async ({
         phase: 'stop',
       })
 
-      return functions
+      return { functions, server }
     } catch {
       statusCb({
         type: 'functions-manifest',
@@ -76,11 +83,13 @@ const getFunctionZips = async ({
     })
   }
 
-  return await zipFunctions(directories, tmpDir, {
+  const functions = await zipFunctions(directories, tmpDir, {
     basePath: rootDir,
     configFileDirectories: [command.getPathInProject(INTERNAL_FUNCTIONS_FOLDER)],
     config: functionsConfig,
   })
+
+  return { functions }
 }
 
 const trafficRulesConfig = (trafficRules?: TrafficRules) => {
@@ -133,6 +142,8 @@ const hashFns = async (
   shaMap?: Record<string, $TSFixMe> | undefined
   fnShaMap?: Record<string, $TSFixMe[]> | undefined
   fnConfig?: Record<string, $TSFixMe> | undefined
+  server?: { sha: string; region?: string } | undefined
+  serverShaMap?: Record<string, $TSFixMe[]> | undefined
 }> => {
   // Exit early if no functions directories are configured.
   if (directories.length === 0) {
@@ -143,7 +154,7 @@ const hashFns = async (
     throw new Error('Missing tmpDir directory for zipping files')
   }
 
-  const functionZips = await getFunctionZips({
+  const { functions: functionZips, server: serverBundle } = await getFunctionZips({
     command,
     directories,
     functionsConfig,
@@ -247,7 +258,49 @@ const hashFns = async (
   const manifestCollector = manifestCollectorCtor(functions, fnShaMap, { statusCb })
 
   await pipeline([functionStream, hasher, manifestCollector])
-  return { functionSchedules, functions, functionsWithNativeModules, fnShaMap, fnConfig }
+
+  const { server, serverShaMap } = await hashServer(serverBundle, { concurrentHash, hashAlgorithm, statusCb, tmpDir })
+
+  return { functionSchedules, functions, functionsWithNativeModules, fnShaMap, fnConfig, server, serverShaMap }
+}
+
+// A deploy has at most one server, so it is declared on its own rather than in a
+// map keyed by name. It still goes through the same hashing pipeline, so the
+// upload flow can treat it like any other artifact.
+const hashServer = async (
+  serverBundle: ServerBundle | undefined,
+  {
+    concurrentHash,
+    hashAlgorithm,
+    statusCb,
+    tmpDir,
+  }: { concurrentHash?: number; hashAlgorithm?: string; statusCb: $TSFixMe; tmpDir: string },
+): Promise<{ server?: { sha: string; region?: string }; serverShaMap?: Record<string, $TSFixMe[]> }> => {
+  if (!serverBundle) {
+    return {}
+  }
+
+  const fileObj = {
+    filepath: serverBundle.path,
+    root: tmpDir,
+    relname: path.relative(tmpDir, serverBundle.path),
+    basename: path.basename(serverBundle.path),
+    extname: path.extname(serverBundle.path),
+    type: 'file',
+    assetType: 'server',
+    normalizedPath: path.basename(serverBundle.path, path.extname(serverBundle.path)),
+  }
+
+  const servers: Record<string, string> = {}
+  const serverShaMap: Record<string, $TSFixMe[]> = {}
+
+  await pipeline([
+    Readable.from([fileObj]),
+    hasherCtor({ concurrentHash, hashAlgorithm }),
+    manifestCollectorCtor(servers, serverShaMap, { statusCb }),
+  ])
+
+  return { server: { sha: Object.values(servers)[0], region: serverBundle.region }, serverShaMap }
 }
 
 export default hashFns

src/utils/deploy/upload-files.ts

@@ -7,14 +7,18 @@ import pMap from 'p-map'
 import { UPLOAD_INITIAL_DELAY, UPLOAD_MAX_DELAY, UPLOAD_RANDOM_FACTOR } from './constants.js'
 import type { StatusCallback } from './status-cb.js'
 
-export type UploadApi = Pick<NetlifyAPI, 'uploadDeployFile' | 'uploadDeployFunction' | 'uploadDeployEdgeFunction'>
+export type UploadApi = Pick<
+  NetlifyAPI,
+  'uploadDeployFile' | 'uploadDeployFunction' | 'uploadDeployEdgeFunction' | 'uploadDeployServer'
+>
 
 // `@netlify/api` only models path and query parameters, so header parameters such as
 // `X-Nf-Retry-Count` have to be added on top of the generated parameter types.
 type WithRetryCount<T> = T & { xNfRetryCount?: number }
 
 type UploadDeployFunctionParams = WithRetryCount<Parameters<UploadApi['uploadDeployFunction']>[0]>
 type UploadDeployEdgeFunctionParams = WithRetryCount<Parameters<UploadApi['uploadDeployEdgeFunction']>[0]>
+type UploadDeployServerParams = WithRetryCount<Parameters<UploadApi['uploadDeployServer']>[0]>
 
 interface UploadFileBase {
   filepath: string
@@ -38,7 +42,12 @@ export interface EdgeFunctionUploadFile extends UploadFileBase {
   hash: string
 }
 
-export type UploadFile = StaticUploadFile | FunctionUploadFile | EdgeFunctionUploadFile
+export interface ServerUploadFile extends UploadFileBase {
+  assetType: 'server'
+  hash: string
+}
+
+export type UploadFile = StaticUploadFile | FunctionUploadFile | EdgeFunctionUploadFile | ServerUploadFile
 
 class MissingAssetTypeError extends Error {
   constructor(readonly fileObj: unknown) {
@@ -123,6 +132,21 @@ const uploadFiles = async (
           return api.uploadDeployEdgeFunction(params)
         }, maxRetry)
       }
+      case 'server': {
+        return await retryUpload((retryCount) => {
+          const params: UploadDeployServerParams = {
+            body: readStreamCtor,
+            deployId,
+            codeSha: fileObj.hash,
+          }
+
+          if (retryCount > 0) {
+            params.xNfRetryCount = retryCount
+          }
+
+          return api.uploadDeployServer(params)
+        }, maxRetry)
+      }
       default: {
         throw new MissingAssetTypeError(fileObj)
       }

tests/unit/utils/deploy/upload-files.test.ts

@@ -117,3 +117,34 @@ test('Does not retry on 400 response from function upload requests', async () =>
 
   expect(uploadDeployFunction).toHaveBeenCalledTimes(1)
 })
+
+test('Uploads a Netlify Server addressed by its digest, and retries it', async () => {
+  const uploadDeployServer = vi.fn()
+  const mockError = new Error('Uh-oh')
+
+  Object.assign(mockError, { status: 500 })
+
+  uploadDeployServer.mockRejectedValueOnce(mockError)
+  uploadDeployServer.mockResolvedValueOnce(undefined)
+
+  const mockApi = {
+    uploadDeployServer,
+  } as unknown as UploadApi
+  const deployId = crypto.randomUUID()
+  const codeSha = 'abc123'
+  const files: UploadFile[] = [
+    {
+      assetType: 'server',
+      filepath: 'server.tgz',
+      normalizedPath: 'server',
+      hash: codeSha,
+    } as unknown as UploadFile,
+  ]
+
+  await uploadFiles(mockApi, deployId, files, { concurrentUpload: 1, maxRetry: 3, statusCb: () => {} })
+
+  expect(uploadDeployServer).toHaveBeenCalledTimes(2)
+  expect(uploadDeployServer.mock.calls[0][0]).not.toHaveProperty('name')
+  expect(uploadDeployServer.mock.calls[0][0]).toMatchObject({ deployId, codeSha })
+  expect(uploadDeployServer.mock.calls[1][0]).toMatchObject({ deployId, codeSha, xNfRetryCount: 1 })
+})