zooid 0.7.4 → 0.9.0

package/src/web/resolve.test.ts

@@ -1,47 +1,75 @@
 import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
-import { afterEach, beforeEach, describe, expect, it } from 'vitest'
-import { resolveWebRoot, webSourcePackage } from './resolve.js'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { ensureWebRoot, webSourcePackage } from './resolve.js'
 
 let root: string
 beforeEach(() => {
   root = mkdtempSync(join(tmpdir(), 'zooid-resolve-'))
 })
-afterEach(() => rmSync(root, { recursive: true, force: true }))
-
-describe('resolveWebRoot', () => {
-  it('returns dist/web when present (published-package layout)', () => {
-    const distWeb = join(root, 'dist', 'web')
-    mkdirSync(distWeb, { recursive: true })
-    writeFileSync(join(distWeb, 'index.html'), '<html/>')
-    expect(resolveWebRoot(root)).toBe(distWeb)
+afterEach(() => {
+  rmSync(root, { recursive: true, force: true })
+  delete process.env.ZOOID_DEV_WEB_ROOT_OVERRIDE
+})
+
+function makeSibling(rootDir: string): { cliRoot: string; webDist: string } {
+  const cliRoot = join(rootDir, 'zooid', 'packages', 'cli')
+  mkdirSync(cliRoot, { recursive: true })
+  const webPkg = join(rootDir, 'zoon', 'packages', 'web')
+  const webDist = join(webPkg, 'dist')
+  mkdirSync(webDist, { recursive: true })
+  writeFileSync(join(webPkg, 'package.json'), '{"name":"@zooid/web"}')
+  writeFileSync(join(webDist, 'index.html'), '<html/>')
+  return { cliRoot, webDist }
+}
+
+describe('ensureWebRoot', () => {
+  it('env override wins over everything and skips the fetch', async () => {
+    const { cliRoot } = makeSibling(root)
+    const override = join(root, 'override')
+    mkdirSync(override, { recursive: true })
+    writeFileSync(join(override, 'index.html'), '<html/>')
+    process.env.ZOOID_DEV_WEB_ROOT_OVERRIDE = override
+    const fetchBundle = vi.fn()
+    const out = await ensureWebRoot({ cliRoot, cacheDir: join(root, 'cache'), version: '0.1.0', fetchBundle })
+    expect(out).toBe(override)
+    expect(fetchBundle).not.toHaveBeenCalled()
   })
 
-  it('falls back to ../../zoon/packages/web/dist when running from source', () => {
-    const cliRoot = join(root, 'zooid', 'packages', 'cli')
+  it('prefers the monorepo sibling dist over the cache (contributor path)', async () => {
+    const { cliRoot, webDist } = makeSibling(root)
+    const fetchBundle = vi.fn()
+    const out = await ensureWebRoot({ cliRoot, cacheDir: join(root, 'cache'), version: '0.1.0', fetchBundle })
+    expect(out).toBe(webDist)
+    expect(fetchBundle).not.toHaveBeenCalled()
+  })
+
+  it('falls back to fetchBundle outside the monorepo (installed-package path)', async () => {
+    const cliRoot = join(root, 'lonely', 'cli')
     mkdirSync(cliRoot, { recursive: true })
-    const webPkg = join(root, 'zoon', 'packages', 'web')
-    const webDist = join(webPkg, 'dist')
-    mkdirSync(webDist, { recursive: true })
-    writeFileSync(join(webPkg, 'package.json'), '{"name":"@zoon/web"}')
-    writeFileSync(join(webDist, 'index.html'), '<html/>')
-    expect(resolveWebRoot(cliRoot)).toBe(webDist)
+    const cached = join(root, 'cache', '0.1.0')
+    const fetchBundle = vi.fn(async () => cached)
+    const out = await ensureWebRoot({ cliRoot, cacheDir: join(root, 'cache'), version: '0.1.0', fetchBundle })
+    expect(out).toBe(cached)
+    expect(fetchBundle).toHaveBeenCalledWith(
+      expect.objectContaining({ version: '0.1.0', cacheDir: join(root, 'cache') }),
+    )
   })
 
-  it('throws a helpful error when neither layout has been built', () => {
-    expect(() => resolveWebRoot(root)).toThrow(/@zoon\/web.*build/i)
+  it('throws an actionable error when no version pin is available outside the monorepo', async () => {
+    const cliRoot = join(root, 'lonely', 'cli')
+    mkdirSync(cliRoot, { recursive: true })
+    await expect(
+      ensureWebRoot({ cliRoot, cacheDir: join(root, 'cache'), version: undefined, fetchBundle: vi.fn() }),
+    ).rejects.toThrow(/webVersion/)
   })
 })
 
 describe('webSourcePackage', () => {
-  it('returns the source package dir when sibling zoon/packages/web exists', () => {
-    const cliRoot = join(root, 'zooid', 'packages', 'cli')
-    mkdirSync(cliRoot, { recursive: true })
-    const webPkg = join(root, 'zoon', 'packages', 'web')
-    mkdirSync(webPkg, { recursive: true })
-    writeFileSync(join(webPkg, 'package.json'), '{"name":"@zoon/web"}')
-    expect(webSourcePackage(cliRoot)).toBe(webPkg)
+  it('returns the source package dir when sibling zooid-clients/packages/web exists', () => {
+    const { cliRoot } = makeSibling(root)
+    expect(webSourcePackage(cliRoot)).toBe(join(root, 'zoon', 'packages', 'web'))
   })
 
   it('returns null outside the monorepo', () => {

package/src/web/resolve.ts

@@ -1,27 +1,39 @@
 import { existsSync } from 'node:fs'
 import { dirname, join, resolve } from 'node:path'
+import { fetchWebBundle, type FetchWebBundleOptions } from './fetch.js'
 
 const ENV_OVERRIDE = 'ZOOID_DEV_WEB_ROOT_OVERRIDE'
 
-export function resolveWebRoot(cliRoot: string): string {
+export interface EnsureWebRootOptions {
+  cliRoot: string
+  cacheDir: string
+  version: string | undefined
+  fetchBundle?: (opts: FetchWebBundleOptions) => Promise<string>
+  onProgress?: (msg: string) => void
+}
+
+export async function ensureWebRoot(opts: EnsureWebRootOptions): Promise<string> {
   const override = process.env[ENV_OVERRIDE]
   if (override && existsSync(join(override, 'index.html'))) return resolve(override)
 
-  const published = join(cliRoot, 'dist', 'web')
-  if (existsSync(join(published, 'index.html'))) return published
-
-  const fromSource = webSourcePackage(cliRoot)
+  const fromSource = webSourcePackage(opts.cliRoot)
   if (fromSource && existsSync(join(fromSource, 'dist', 'index.html'))) {
     return join(fromSource, 'dist')
   }
 
-  throw new Error(
-    `@zoon/web build not found.\n  Tried: ${published}\n  Tried: ${fromSource ?? '(no monorepo source)'}\n` +
-      `Run \`pnpm -C zoon/packages/web build\` (or set ${ENV_OVERRIDE} to a built dist).`,
-  )
+  if (!opts.version) {
+    throw new Error(
+      `No @zooid/web version pin (zooid.webVersion) in the cli package.json ` +
+        `and no monorepo sibling build found.\n` +
+        `Set ${ENV_OVERRIDE} to a built dist, or run from the monorepo.`,
+    )
+  }
+  opts.onProgress?.(`Fetching @zooid/web ${opts.version}…`)
+  const fetchBundleFn = opts.fetchBundle ?? fetchWebBundle
+  return fetchBundleFn({ version: opts.version, cacheDir: opts.cacheDir })
 }
 
-// Returns the path to the in-tree @zoon/web package (zoon/packages/web) if the
+// Returns the path to the in-tree @zooid/web package (zooid-clients/packages/web) if the
 // CLI is running from the monorepo source. Returns null when running from an
 // installed package (no sibling zoon/ tree).
 export function webSourcePackage(cliRoot: string): string | null {

package/src/web/test-helpers.ts

@@ -0,0 +1,28 @@
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { dirname, join } from 'node:path'
+import { createHash } from 'node:crypto'
+import * as tar from 'tar'
+
+export function makeBundleTgz(
+  files: Record<string, string> = {
+    'package/package.json': '{"name":"@zooid/web"}',
+    'package/dist/index.html': '<html>zoon</html>',
+    'package/dist/assets/app.js': '// app',
+  },
+): { tgz: Buffer; integrity: string } {
+  const dir = mkdtempSync(join(tmpdir(), 'zooid-tgz-'))
+  try {
+    for (const [path, content] of Object.entries(files)) {
+      mkdirSync(join(dir, dirname(path)), { recursive: true })
+      writeFileSync(join(dir, path), content)
+    }
+    const tgz = tar
+      .create({ sync: true, gzip: true, cwd: dir, portable: true }, ['package'])
+      .read() as Buffer
+    const integrity = 'sha512-' + createHash('sha512').update(tgz).digest('base64')
+    return { tgz, integrity }
+  } finally {
+    rmSync(dir, { recursive: true, force: true })
+  }
+}