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

npm-pack.ts

321 lines9.5 KB

1/**
2 * Pack the public workspace packages for npm.
3 *
4 * Bun's packer rewrites `workspace:*` to the concrete versions npm
5 * consumers need. This script only writes tarballs. Staging is
6 * `npm stage publish` from `.github/workflows/publish.yml` (OIDC, env
7 * `npm`, workflow filename `publish.yml`) so the trusted-publisher
8 * match holds. Future Actions stages get provenance; laptop `0.1.0`
9 * did not.
10 *
11 * bun scripts/npm-pack.ts # dist/npm, then stop
12 * bun scripts/npm-pack.ts --pack-dir /tmp/npm
13 *
14 * If `--tag` or `RELEASE_TAG` is set, it must be `vMAJOR.MINOR.PATCH`
15 * (optional prerelease) and match every public package's version.
16 */
17import {
18 existsSync,
19 mkdirSync,
20 readdirSync,
21 readFileSync,
22 rmSync,
23} from 'node:fs'
24import { join, resolve } from 'node:path'
25import { spawnSync } from 'node:child_process'
26​
27export type PublicPackage = {
28 name: string
29 version: string
30 dir: string
31 dependencies: Record<string, string>
33​
34const WORKSPACE_OR_CATALOG = /^(workspace|catalog):/
35​
36export function repoRoot(): string {
37 return join(import.meta.dirname, '..')
39​
40export function tarballFileName(name: string, version: string): string {
41 const unscoped = name.startsWith('@') ? name.slice(1).replace('/', '-') : name
42 return `${unscoped}-${version}.tgz`
44​
45/** `v0.1.0`, `refs/tags/v0.1.0`, or `v1.2.3-rc.1` → version. Else undefined. */
46export function versionFromTag(tag: string): string | undefined {
47 const trimmed = tag.replace(/^refs\/tags\//, '')
48 if (!/^v\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(trimmed)) return undefined
49 return trimmed.slice(1)
51​
52export function listPublicPackages(
53 packagesDir: string = join(repoRoot(), 'packages'),
54): Array<PublicPackage> {
55 const pkgs: Array<PublicPackage> = []
56 for (const entry of readdirSync(packagesDir, { withFileTypes: true })) {
57 if (!entry.isDirectory()) continue
58 const pkgPath = join(packagesDir, entry.name, 'package.json')
59 let raw: string
60 try {
61 raw = readFileSync(pkgPath, 'utf8')
62 } catch {
63 continue
64 }
65 const parsed: unknown = JSON.parse(raw)
66 const pkg = asPackageJson(parsed, pkgPath)
67 if (pkg.private) continue
68 pkgs.push({
69 name: pkg.name,
70 version: pkg.version,
71 dir: join(packagesDir, entry.name),
72 dependencies: pkg.dependencies,
73 })
74 }
75 pkgs.sort((a, b) => a.name.localeCompare(b.name))
76 return pkgs
78​
79/** Dependents last (client/codegen, then vite, CLI) — npmjs.com approve order. */
80export function publishOrder(
81 packages: Array<PublicPackage>,
82): Array<PublicPackage> {
83 const byName = new Map(packages.map((pkg) => [pkg.name, pkg]))
84 const remaining = new Set(packages.map((pkg) => pkg.name))
85 const ordered: Array<PublicPackage> = []
86 while (remaining.size > 0) {
87 const ready = [...remaining]
88 .filter((name) => {
89 const pkg = byName.get(name)
90 if (!pkg) return false
91 return Object.keys(pkg.dependencies).every((dep) => !remaining.has(dep))
92 })
93 .sort()
94 if (ready.length === 0) {
95 throw new Error(
96 `workspace dependency cycle among ${[...remaining].join(', ')}`,
97 )
98 }
99 for (const name of ready) {
100 remaining.delete(name)
101 const pkg = byName.get(name)
102 if (!pkg) throw new Error(`missing package ${name}`)
103 ordered.push(pkg)
104 }
105 }
106 return ordered
108​
109export function assertVersionsMatchTag(
110 packages: Array<PublicPackage>,
111 tag: string,
112): void {
113 const expected = versionFromTag(tag)
114 if (expected === undefined) {
115 throw new Error(
116 `release tag ${JSON.stringify(tag)} is not vMAJOR.MINOR.PATCH`,
117 )
118 }
119 const mismatches = packages.filter((pkg) => pkg.version !== expected)
120 if (mismatches.length > 0) {
121 const detail = mismatches
122 .map((pkg) => `${pkg.name}@${pkg.version}`)
123 .join(', ')
124 throw new Error(
125 `tag v${expected} does not match package versions: ${detail}`,
126 )
127 }
129​
130export function assertPublishableManifest(
131 manifest: unknown,
132 source: string,
133): void {
134 const pkg = asPackageJson(manifest, source)
135 if (pkg.private) {
136 throw new Error(`${source}: packed manifest is private`)
137 }
138 for (const [name, spec] of Object.entries(pkg.dependencies)) {
139 if (WORKSPACE_OR_CATALOG.test(spec)) {
140 throw new Error(`${source}: ${name} still uses ${spec}`)
141 }
142 }
144​
145export function readPackedManifest(tarball: string): unknown {
146 const result = spawnSync('tar', ['-xOf', tarball, 'package/package.json'], {
147 encoding: 'utf8',
148 })
149 if (result.status !== 0) {
150 throw new Error(
151 `tar -xOf ${tarball} package/package.json failed: ${result.stderr}`,
152 )
153 }
154 return JSON.parse(result.stdout) as unknown
156​
157export function packedEntryNames(tarball: string): Array<string> {
158 const result = spawnSync('tar', ['-tzf', tarball], { encoding: 'utf8' })
159 if (result.status !== 0) {
160 throw new Error(`tar -tzf ${tarball} failed: ${result.stderr}`)
161 }
162 return result.stdout.split('\n').filter((line) => line.length > 0)
164​
165/** Absolute dest so `bun pm pack` (cwd = package dir) writes where we look. */
166export function resolvePackDir(packDir: string): string {
167 return resolve(packDir)
169​
170export function packPackage(pkg: PublicPackage, packDir: string): string {
171 const dest = resolvePackDir(packDir)
172 mkdirSync(dest, { recursive: true })
173 const result = spawnSync(
174 'bun',
175 ['pm', 'pack', '--destination', dest, '--quiet'],
176 { cwd: pkg.dir, encoding: 'utf8' },
177 )
178 if (result.status !== 0) {
179 throw new Error(
180 `bun pm pack ${pkg.name} failed: ${result.stderr || result.stdout}`,
181 )
182 }
183 const tarball = join(dest, tarballFileName(pkg.name, pkg.version))
184 if (!existsSync(tarball)) {
185 throw new Error(
186 `expected ${tarball} after bun pm pack; stdout=${result.stdout.trim()}`,
187 )
188 }
189 return tarball
191​
192export function packAll(
193 packages: Array<PublicPackage>,
194 packDir: string,
195): Array<{ pkg: PublicPackage; tarball: string }> {
196 const dest = resolvePackDir(packDir)
197 rmSync(dest, { recursive: true, force: true })
198 mkdirSync(dest, { recursive: true })
199 const packed: Array<{ pkg: PublicPackage; tarball: string }> = []
200 for (const pkg of packages) {
201 const tarball = packPackage(pkg, dest)
202 assertPublishableManifest(readPackedManifest(tarball), tarball)
203 const entries = packedEntryNames(tarball)
204 const tests = entries.filter((entry) => entry.endsWith('.test.ts'))
205 if (tests.length > 0) {
206 throw new Error(`${tarball} includes test files: ${tests.join(', ')}`)
207 }
208 packed.push({ pkg, tarball })
209 }
210 return packed
212​
213function asPackageJson(
214 value: unknown,
215 source: string,
216): {
217 name: string
218 version: string
219 private: boolean
220 dependencies: Record<string, string>
221} {
222 if (!isRecord(value)) {
223 throw new Error(`${source}: package.json is not an object`)
224 }
225 if (typeof value.name !== 'string' || typeof value.version !== 'string') {
226 throw new Error(`${source}: name and version must be strings`)
227 }
228 return {
229 name: value.name,
230 version: value.version,
231 private: value.private === true,
232 dependencies: {
233 ...stringRecord(value.dependencies, `${source} dependencies`),
234 ...stringRecord(
235 value.optionalDependencies,
236 `${source} optionalDependencies`,
237 ),
238 ...stringRecord(value.peerDependencies, `${source} peerDependencies`),
239 },
240 }
242​
243function isRecord(value: unknown): value is Record<string, unknown> {
244 return typeof value === 'object' && value !== null && !Array.isArray(value)
246​
247function stringRecord(value: unknown, source: string): Record<string, string> {
248 if (value === undefined) return {}
249 if (!isRecord(value)) throw new Error(`${source}: expected an object`)
250 const out: Record<string, string> = {}
251 for (const [key, spec] of Object.entries(value)) {
252 if (typeof spec !== 'string') {
253 throw new Error(`${source}: ${key} is not a string`)
254 }
255 out[key] = spec
256 }
257 return out
259​
260function parseCli(argv: Array<string>): {
261 packDir: string | undefined
262 tag: string | undefined
263} {
264 let packDir: string | undefined
265 let tag: string | undefined
266 for (let i = 0; i < argv.length; i += 1) {
267 const arg = argv[i]
268 if (arg === '--pack-dir') {
269 const value = argv[i + 1]
270 if (value === undefined) throw new Error('--pack-dir requires a path')
271 packDir = value
272 i += 1
273 continue
274 }
275 if (arg === '--tag') {
276 const value = argv[i + 1]
277 if (value === undefined) throw new Error('--tag requires a value')
278 tag = value
279 i += 1
280 continue
281 }
282 throw new Error(`unknown argument: ${arg}`)
283 }
284 return { packDir, tag }
286​
287export function main(argv: Array<string> = process.argv.slice(2)): void {
288 const flags = parseCli(argv)
289 const packages = publishOrder(listPublicPackages())
290 if (packages.length === 0) {
291 throw new Error('no public packages under packages/')
292 }
293 const tag = flags.tag ?? process.env.RELEASE_TAG
294 if (tag !== undefined && tag !== '') {
295 assertVersionsMatchTag(packages, tag)
296 }
297 const packDir = resolvePackDir(
298 flags.packDir ??
299 process.env.NPM_PACK_DIR ??
300 join(repoRoot(), 'dist', 'npm'),
301 )
302 const packed = packAll(packages, packDir)
303 console.log(`packed ${packed.length} packages → ${packDir}\n`)
304 for (const { pkg, tarball } of packed) {
305 console.log(` ${pkg.name}@${pkg.version}`)
306 console.log(` ${tarball}`)
307 }
308 console.log(
309 `\nNext: npm stage publish happens in .github/workflows/publish.yml (OIDC).`,
310 )
312​
313if (import.meta.main) {
314 try {
315 main()
316 } catch (error) {
317 const message = error instanceof Error ? error.message : String(error)
318 console.error(message)
319 process.exit(1)
320 }