Skip to content
Source
Sign inSign up
TanStack/cli
Open History to see the last commit

verify-release-artifacts.mjs

218 lines6.7 KB

1import { createHash } from 'node:crypto'
2import { execFileSync } from 'node:child_process'
3import { createWriteStream } from 'node:fs'
4import { mkdtemp, rm } from 'node:fs/promises'
5import { tmpdir } from 'node:os'
6import { join, resolve } from 'node:path'
7import { Readable, Transform } from 'node:stream'
8import { pipeline } from 'node:stream/promises'
9import { fileURLToPath } from 'node:url'
10​
11class NotAvailable extends Error {
12 constructor(message, retryAfterMs = 0) {
13 super(message)
14 this.retryAfterMs = retryAfterMs
15 }
17​
18async function fetchAvailable(url, fetchImpl, requestTimeoutMs) {
19 let response
20 try {
21 response = await fetchImpl(url, {
22 signal: AbortSignal.timeout(requestTimeoutMs),
23 })
24 } catch (error) {
25 throw new NotAvailable(`${url}: ${error.message}`)
26 }
27 if (
28 response.status === 404 ||
29 response.status === 429 ||
30 response.status >= 500
31 ) {
32 const retryAfter = response.headers.get('retry-after')
33 const retryAfterMs =
34 retryAfter && /^\d+$/.test(retryAfter)
35 ? Number(retryAfter) * 1000
36 : retryAfter
37 ? Math.max(0, Date.parse(retryAfter) - Date.now())
38 : 0
39 await response.body?.cancel()
40 throw new NotAvailable(`${url}: HTTP ${response.status}`, retryAfterMs)
41 }
42 if (!response.ok) {
43 await response.body?.cancel()
44 throw new Error(`${url}: HTTP ${response.status}`)
45 }
46 return response
48​
49async function verifyPackage(pkg, { registry, fetchImpl, requestTimeoutMs }) {
50 const metadataURL = `${registry.origin}/${encodeURIComponent(pkg.name)}/${encodeURIComponent(pkg.version)}`
51 const metadataResponse = await fetchAvailable(
52 metadataURL,
53 fetchImpl,
54 requestTimeoutMs,
55 )
56 let metadata
57 try {
58 metadata = await metadataResponse.json()
59 } catch (error) {
60 throw new NotAvailable(`${metadataURL}: ${error.message}`)
61 }
62 if (metadata.name !== pkg.name || metadata.version !== pkg.version) {
63 throw new Error(`Registry identity mismatch for ${pkg.name}@${pkg.version}`)
64 }
65 const integrity = metadata.dist?.integrity
66 ?.split(/\s+/)
67 .find((value) => /^sha512-[A-Za-z0-9+/]+={0,2}$/.test(value))
68 if (!integrity)
69 throw new Error(`Missing SHA512 integrity for ${pkg.name}@${pkg.version}`)
70 const tarballURL = new URL(metadata.dist.tarball)
71 if (tarballURL.origin !== registry.origin) {
72 throw new Error(`Unexpected tarball origin for ${pkg.name}@${pkg.version}`)
73 }
74 const response = await fetchAvailable(tarballURL, fetchImpl, requestTimeoutMs)
75 if (!response.body)
76 throw new Error(`Empty tarball for ${pkg.name}@${pkg.version}`)
77 const directory = await mkdtemp(join(tmpdir(), 'tanstack-release-'))
78 const archive = join(directory, 'package.tgz')
79 const hash = createHash('sha512')
80 let bytes = 0
81 try {
82 try {
83 await pipeline(
84 Readable.fromWeb(response.body),
85 new Transform({
86 transform(chunk, _encoding, callback) {
87 hash.update(chunk)
88 bytes += chunk.length
89 callback(null, chunk)
90 },
91 }),
92 createWriteStream(archive),
93 )
94 } catch (error) {
95 if (
96 error instanceof TypeError ||
97 ['AbortError', 'TimeoutError'].includes(error.name)
98 ) {
99 throw new NotAvailable(
100 `Tarball download interrupted for ${pkg.name}@${pkg.version}: ${error.message}`,
101 )
102 }
103 throw error
104 }
105 if (`sha512-${hash.digest('base64')}` !== integrity) {
106 throw new Error(
107 `Tarball integrity mismatch for ${pkg.name}@${pkg.version}`,
108 )
109 }
110 const packed = JSON.parse(
111 execFileSync('tar', ['-xOzf', archive, 'package/package.json'], {
112 encoding: 'utf8',
113 maxBuffer: 1024 * 1024,
114 }),
115 )
116 if (packed.name !== pkg.name || packed.version !== pkg.version) {
117 throw new Error(`Packed identity mismatch for ${pkg.name}@${pkg.version}`)
118 }
119 for (const [name, version] of Object.entries(pkg.dependencies ?? {})) {
120 if (packed.dependencies?.[name] !== version) {
121 throw new Error(`Packed dependency mismatch for ${pkg.name}: ${name}@${version}`)
122 }
123 }
124 return { ...pkg, integrity, bytes }
125 } finally {
126 await rm(directory, { recursive: true, force: true })
127 }
129​
130export async function verifyReleaseArtifacts(
131 packages,
132 {
133 registryURL = 'https://registry.npmjs.org',
134 fetchImpl = fetch,
135 now = Date.now,
136 sleep = (ms) => new Promise((done) => setTimeout(done, ms)),
137 timeoutMs = 20 * 60 * 1000,
138 pollMs = 15 * 1000,
139 log = console.log,
140 } = {},
141) {
142 if (
143 !Array.isArray(packages) ||
144 !packages.length ||
145 packages.some(
146 (pkg) =>
147 !pkg ||
148 typeof pkg.name !== 'string' ||
149 !pkg.name ||
150 typeof pkg.version !== 'string' ||
151 !pkg.version,
152 )
153 ) {
154 throw new Error('Expected published package names and versions')
155 }
156 if (
157 !Number.isFinite(timeoutMs) ||
158 timeoutMs <= 0 ||
159 !Number.isFinite(pollMs) ||
160 pollMs <= 0
161 ) {
162 throw new Error('Verification timeout and poll interval must be positive')
163 }
164 const registry = new URL(registryURL)
165 if (registry.protocol !== 'https:')
166 throw new Error('The registry must use HTTPS')
167 const deadline = now() + timeoutMs
168 const pending = new Map(
169 packages.map((pkg) => [`${pkg.name}@${pkg.version}`, pkg]),
170 )
171 const verified = []
172 let lastReasons = []
173 while (pending.size) {
174 let retryAfterMs = pollMs
175 lastReasons = []
176 for (const [id, pkg] of pending) {
177 if (now() >= deadline) break
178 try {
179 const receipt = await verifyPackage(pkg, {
180 registry,
181 fetchImpl,
182 requestTimeoutMs: Math.max(1, Math.min(30_000, deadline - now())),
183 })
184 verified.push(receipt)
185 pending.delete(id)
186 log(
187 `Verified ${id}: SHA512 and packed identity (${receipt.bytes} bytes)`,
188 )
189 } catch (error) {
190 if (!(error instanceof NotAvailable)) throw error
191 retryAfterMs = Math.max(retryAfterMs, error.retryAfterMs || 0)
192 lastReasons.push(`${id}: ${error.message}`)
193 }
194 }
195 if (!pending.size) return verified
196 const remaining = deadline - now()
197 if (remaining <= 0 || retryAfterMs > remaining) break
198 log(`Waiting for npm availability: ${lastReasons.join('; ')}`)
199 await sleep(retryAfterMs)
200 }
201 throw new Error(
202 `Release is not ready: ${[...pending.keys()].join(', ')}. ${lastReasons.join('; ')}. The version may still be scanned or staged. Rerun this verification job after availability changes, without rerunning the publisher.`,
203 )
205​
206if (
207 process.argv[1] &&
208 resolve(process.argv[1]) === fileURLToPath(import.meta.url)
209) {
210 try {
211 await verifyReleaseArtifacts(
212 JSON.parse(process.env.PUBLISHED_PACKAGES || 'null'),
213 )
214 } catch (error) {
215 console.error(error.message)
216 process.exitCode = 1
217 }