feat: add support for conditional writes to BlobsServer (#306)

Author: eduardoboucas

packages/blobs/src/server.test.ts

@@ -463,3 +463,55 @@ test('Accepts deploy-scoped stores with the region defined in the context', asyn
   await server.stop()
   await fs.rm(directory.path, { force: true, recursive: true })
 })
+
+test('Handles conditional writes', async () => {
+  const directory = await tmp.dir()
+  const server = new BlobsServer({
+    directory: directory.path,
+    token,
+  })
+  const { port } = await server.start()
+  const deployID = '655f77a1b48f470008e5879a'
+  const key = 'conditional-key'
+  const value1 = 'value 1'
+  const value2 = 'value 2'
+  const value3 = 'value 3'
+
+  const context = {
+    deployID,
+    edgeURL: `http://localhost:${port}`,
+    primaryRegion: 'us-east-1',
+    siteID,
+    token,
+  }
+
+  env.NETLIFY_BLOBS_CONTEXT = Buffer.from(JSON.stringify(context)).toString('base64')
+
+  const store1 = getStore({
+    edgeURL: `http://localhost:${port}`,
+    name: 'my-store',
+    token,
+    siteID,
+  })
+
+  const res1 = await store1.set(key, value1, { onlyIfNew: true })
+
+  expect(res1.modified).toBe(true)
+  expect(await store1.get(key)).toBe(value1)
+
+  const res2 = await store1.set(key, value2, { onlyIfNew: true })
+
+  expect(res2.modified).toBe(false)
+  expect(await store1.get(key)).toBe(value1)
+
+  const res3 = await store1.set(key, value3, { onlyIfMatch: `"wrong-etag"` })
+  expect(res3.modified).toBe(false)
+  expect(await store1.get(key)).toBe(value1)
+
+  const res4 = await store1.set(key, value3, { onlyIfMatch: res1.etag })
+  expect(res4.modified).toBe(true)
+  expect(await store1.get(key)).toBe(value3)
+
+  await server.stop()
+  await fs.rm(directory.path, { force: true, recursive: true })
+})

packages/blobs/src/server.ts

@@ -189,6 +189,8 @@ export class BlobsServer {
         return new Response(null, { status: 404 })
       }
 
+      this.logDebug('Error when reading data:', error)
+
       return new Response(null, { status: 500 })
     }
   }
@@ -291,16 +293,36 @@ export class BlobsServer {
       return new Response(null, { status: 400 })
     }
 
-    const metadataHeader = req.headers.get(METADATA_HEADER_INTERNAL)
-    const metadata = decodeMetadata(metadataHeader)
+    // Check conditional write headers.
+    const ifMatch = req.headers.get('if-match')
+    const ifNoneMatch = req.headers.get('if-none-match')
 
     try {
+      let fileExists = false
+      try {
+        await fs.access(dataPath)
+
+        fileExists = true
+      } catch {}
+
+      const currentEtag = fileExists ? await BlobsServer.generateETag(dataPath) : undefined
+
+      if (ifNoneMatch === '*' && fileExists) {
+        return new Response(null, { status: 412 })
+      }
+
+      if (ifMatch && (!fileExists || ifMatch !== currentEtag)) {
+        return new Response(null, { status: 412 })
+      }
+
+      const metadataHeader = req.headers.get(METADATA_HEADER_INTERNAL)
+      const metadata = decodeMetadata(metadataHeader)
+
       // We can't have multiple requests writing to the same file, which could
       // happen if multiple clients try to write to the same key at the same
       // time. To prevent this, we write to a temporary file first and then
       // atomically move it to its final destination.
       const tempPath = join(tmpdir(), Math.random().toString())
-
       const body = await req.arrayBuffer()
       await fs.writeFile(tempPath, Buffer.from(body))
       await fs.mkdir(dirname(dataPath), { recursive: true })
@@ -311,10 +333,18 @@ export class BlobsServer {
         await fs.writeFile(metadataPath, JSON.stringify(metadata))
       }
 
-      return new Response(null, { status: 200 })
-    } catch (error) {
-      this.logDebug('Error when writing data:', error)
+      const newEtag = await BlobsServer.generateETag(dataPath)
 
+      return new Response(null, {
+        status: 200,
+        headers: {
+          etag: newEtag,
+        },
+      })
+    } catch (error) {
+      if (isNodeError(error)) {
+        this.logDebug('Error when writing data:', error)
+      }
       return new Response(null, { status: 500 })
     }
   }
@@ -356,6 +386,20 @@ export class BlobsServer {
     return { dataPath, key: key.join('/'), metadataPath, rootPath: storePath }
   }
 
+  /**
+   * Helper method to generate an ETag for a file based on its path and last modified time.
+   */
+  private static async generateETag(filePath: string): Promise<string> {
+    try {
+      const stats = await fs.stat(filePath)
+      const hash = createHmac('sha256', stats.mtime.toISOString()).update(filePath).digest('hex')
+
+      return `"${hash}"`
+    } catch {
+      return ''
+    }
+  }
+
   private async handleRequest(req: Request): Promise<Response> {
     if (!req.url || !this.validateAccess(req)) {
       return new Response(null, { status: 403 })
@@ -502,9 +546,8 @@ export class BlobsServer {
 
       // If the entry is a file, add it to the `blobs` bucket.
       if (!stat.isDirectory()) {
-        // We don't support conditional requests in the local server, so we
-        // generate a random ETag for each entry.
-        const etag = Math.random().toString().slice(2)
+        // Generate a deterministic ETag based on file path and last modified time.
+        const etag = await this.generateETag(entryPath)
 
         result.blobs?.push({
           etag,