@c9up/ream 0.2.28 → 0.2.30

package/scripts/build-napi-types.mjs

@@ -1,69 +0,0 @@
-#!/usr/bin/env node
-/**
- * Regenerate `src/native/generated.ts` from the Rust.
- *
- * Node rather than a shell script because this runs inside `build:napi`, and
- * that runs on the Windows prebuild runner too: a bash `mktemp` there hands
- * cargo a `/tmp/...` path the native proc-macro cannot write to, so the
- * type-def file comes back empty and the build fails for no visible reason.
- *
- * One crate at a time on purpose: with napi-derive 2 the writes all went to a
- * single `TYPE_DEF_TMP_PATH` and a parallel build interleaved them
- * while cargo compiles, and a parallel build interleaves the writes —
- * definitions go missing, silently, and the generated file comes out short.
- */
-
-import { execFileSync } from 'node:child_process'
-import { createRequire } from 'node:module'
-import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { dirname, join } from 'node:path'
-import { fileURLToPath } from 'node:url'
-
-const CRATES = ['ream-events-napi', 'ream-http-napi', 'ream-scheduler-napi']
-
-const packageRoot = join(dirname(fileURLToPath(import.meta.url)), '..')
-const output = join('src', 'native', 'generated.ts')
-const scratch = mkdtempSync(join(tmpdir(), 'napi-types-'))
-
-try {
-  const lines = []
-  for (const crate of CRATES) {
-    const perCrate = join(scratch, crate)
-    writeFileSync(perCrate, '')
-    execFileSync('cargo', ['build', '-p', crate], {
-      cwd: packageRoot,
-      env: { ...process.env, NAPI_TYPE_DEF_TMP_FOLDER: scratch },
-      stdio: ['ignore', 'ignore', 'inherit'],
-    })
-    const emitted = readFileSync(perCrate, 'utf8').split('\n').filter(Boolean)
-    if (emitted.length === 0) {
-      throw new Error(
-        `[napi-types] ${crate} emitted nothing — is napi-derive's "type-def" feature on?`,
-      )
-    }
-    lines.push(...emitted)
-  }
-
-  const combined = join(scratch, 'combined.jsonl')
-  writeFileSync(combined, `${lines.join('\n')}\n`)
-
-  execFileSync(
-    process.execPath,
-    [join('scripts', 'generate-napi-types.mjs'), combined, output],
-    { cwd: packageRoot, stdio: 'inherit' },
-  )
-
-  // Formatted here rather than excluded from the linter: the file is checked
-  // in, so it should read like the rest of the tree — and formatting it at
-  // generation means it never shows up as a diff someone has to fix by hand.
-  // Resolved through the package entry rather than `node_modules/.bin`, whose
-  // shim is a shell script the Windows runner cannot execute directly.
-  const biome = createRequire(import.meta.url).resolve('@biomejs/biome/bin/biome')
-  execFileSync(process.execPath, [biome, 'format', '--write', output], {
-    cwd: packageRoot,
-    stdio: ['ignore', 'ignore', 'inherit'],
-  })
-} finally {
-  rmSync(scratch, { recursive: true, force: true })
-}

package/scripts/copy-napi.mjs

@@ -1,121 +0,0 @@
-// Copy every freshly-built Ream NAPI cdylib out of cargo's target
-// directory and into the package root with the platform-suffix naming
-// convention used by `napi-loader.ts`:
-//
-//     packages/ream/index.linux-x64-gnu.node       (ream-http-napi)
-//     packages/ream/scheduler.linux-x64-gnu.node   (ream-scheduler-napi)
-//     packages/ream/index.darwin-arm64.node
-//     ...
-//
-// The TS loader walks two upper directories from each `loadNapi` caller
-// to find these files, so the binaries MUST live at the package root
-// (not under target/) to be discovered at runtime.
-//
-// Usage:
-//
-//     pnpm --filter @c9up/ream build:rust     # cargo build --release
-//     pnpm --filter @c9up/ream build:napi     # build:rust + this script
-//
-// The package.json script chains both steps. CI / npm publish runs
-// `build:napi` once per platform during the matrix build — every
-// crate listed in `NAPI_CRATES` ships in the tarball.
-
-import { copyFileSync, existsSync } from 'node:fs'
-import { dirname, join, resolve } from 'node:path'
-import { arch, env, platform } from 'node:process'
-import { fileURLToPath } from 'node:url'
-
-const here = dirname(fileURLToPath(import.meta.url))
-const root = join(here, '..')
-
-// Rust target triple -> { suffix, os }. Set CARGO_BUILD_TARGET to cross-compile
-// (e.g. build the x86_64-apple-darwin binary on an arm64 macOS runner so we
-// don't depend on the scarce macos-13 Intel runners). When unset we fall back
-// to the host platform/arch and the default target/release dir.
-const TRIPLE_MAP = {
-  'x86_64-unknown-linux-gnu': { suffix: 'linux-x64-gnu', os: 'linux' },
-  'aarch64-unknown-linux-gnu': { suffix: 'linux-arm64-gnu', os: 'linux' },
-  'x86_64-apple-darwin': { suffix: 'darwin-x64', os: 'darwin' },
-  'aarch64-apple-darwin': { suffix: 'darwin-arm64', os: 'darwin' },
-  'x86_64-pc-windows-msvc': { suffix: 'win32-x64-msvc', os: 'win32' },
-}
-
-const HOST_SUFFIX_MAP = {
-  'linux-x64': 'linux-x64-gnu',
-  'linux-arm64': 'linux-arm64-gnu',
-  'darwin-x64': 'darwin-x64',
-  'darwin-arm64': 'darwin-arm64',
-  'win32-x64': 'win32-x64-msvc',
-}
-
-// Cargo writes its artifacts under CARGO_TARGET_DIR when that is set — a
-// shared cache, a CI mount — so they are not under this package's `target/` at
-// all. A relative value is resolved against the directory cargo ran in, which
-// is this package root.
-const targetDir = env.CARGO_TARGET_DIR
-  ? resolve(root, env.CARGO_TARGET_DIR)
-  : join(root, 'target')
-
-const triple = env.CARGO_BUILD_TARGET ?? ''
-let suffix
-let os
-let releaseDir
-if (triple) {
-  const entry = TRIPLE_MAP[triple]
-  if (!entry) {
-    throw new Error(`[ream:napi] unsupported CARGO_BUILD_TARGET: ${triple}`)
-  }
-  suffix = entry.suffix
-  os = entry.os
-  releaseDir = join(targetDir, triple, 'release')
-} else {
-  suffix = HOST_SUFFIX_MAP[`${platform}-${arch}`]
-  os = platform
-  releaseDir = join(targetDir, 'release')
-  if (!suffix) {
-    throw new Error(`[ream:napi] unsupported platform/arch: ${platform}-${arch}`)
-  }
-}
-
-// Every NAPI crate shipped from the @c9up/ream package. `crateLib` is the
-// underscore-suffixed name cargo produces under `target/release/`;
-// `targetName` is what `loadNapi({ binaryName })` expects at the package
-// root (see `napi-loader.ts` — the binary lookup prefix matches the
-// `binaryName` option passed by each TS consumer).
-const NAPI_CRATES = [
-  { crateLib: 'ream_http_napi', targetName: 'index' },
-  { crateLib: 'ream_scheduler_napi', targetName: 'scheduler' },
-  { crateLib: 'ream_events_napi', targetName: 'events' },
-]
-
-// `crate-type = ["cdylib"]` settles on the platform-conventional file
-// name. Linux + macOS prepend `lib`; Windows drops the prefix and uses
-// `.dll`. Check both Windows shapes so we degrade gracefully if upstream
-// cargo ever switches naming.
-function buildCandidates(crateLib) {
-  if (os === 'win32') {
-    return [
-      join(releaseDir, `${crateLib}.dll`),
-      join(releaseDir, `lib${crateLib}.dll`),
-    ]
-  }
-  if (os === 'darwin') {
-    return [join(releaseDir, `lib${crateLib}.dylib`)]
-  }
-  return [join(releaseDir, `lib${crateLib}.so`)]
-}
-
-for (const { crateLib, targetName } of NAPI_CRATES) {
-  const candidates = buildCandidates(crateLib)
-  const source = candidates.find((candidate) => existsSync(candidate))
-  if (!source) {
-    throw new Error(
-      `[ream:napi] native library for '${crateLib}' not found. Looked for:\n${candidates
-        .map((p) => `- ${p}`)
-        .join('\n')}\nRun 'pnpm --filter @c9up/ream build:rust' first.`,
-    )
-  }
-  const target = join(root, `${targetName}.${suffix}.node`)
-  copyFileSync(source, target)
-  console.log(`[ream:napi] copied ${source} -> ${target}`)
-}

package/scripts/generate-mime.mjs

@@ -1,119 +0,0 @@
-/**
- * Regenerate `src/http/mime.ts` from mime-db.
- *
- * The table is data, not logic, and hand-maintaining it is how `.yaml` and
- * `.sql` went missing. `mime-types` reads the same two fields out of mime-db —
- * the resolved extension map and the per-type `charset` — so generating from
- * there keeps `contentType()` answering exactly what the package answered.
- *
- * mime-db and mime-types are dev-only: they are read HERE, at generation time,
- * and never imported by the framework.
- *
- *     node scripts/generate-mime.mjs
- */
-
-import { createRequire } from 'node:module'
-import { writeFile } from 'node:fs/promises'
-import { fileURLToPath } from 'node:url'
-import { dirname, join } from 'node:path'
-
-const require = createRequire(import.meta.url)
-const mimeTypes = require('mime-types')
-const db = require('mime-db')
-const dbVersion = require('mime-db/package.json').version
-
-const here = dirname(fileURLToPath(import.meta.url))
-const target = join(here, '..', 'src', 'http', 'mime.ts')
-
-/**
- * Emitted in the package's own style — single quotes, no semicolons — so a
- * regenerated file is already what `biome check` wants and the diff after a
- * regeneration is the data that changed, nothing else.
- */
-const quote = (value) => `'${value.replace(/\\/g, '\\\\').replace(/'/g, "\\'")}'`
-/** An identifier when it is one, a quoted key otherwise (`7z`, `3gp`…). */
-const key = (ext) => (/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(ext) ? ext : quote(ext))
-
-const extensions = Object.keys(mimeTypes.types).sort()
-const rows = extensions.map((e) => `  ${key(e)}: ${quote(mimeTypes.types[e])},`).join('\n')
-
-const charsets = Object.entries(db)
-  .filter(([, entry]) => entry.charset)
-  .sort(([a], [b]) => a.localeCompare(b))
-  .map(([type, entry]) => `  ${quote(type)}: ${quote(entry.charset.toLowerCase())},`)
-  .join('\n')
-
-await writeFile(target, render({ rows, charsets, dbVersion, count: extensions.length }))
-process.stdout.write(`mime.ts: ${extensions.length} extensions from mime-db ${dbVersion}\n`)
-
-function render({ rows, charsets, dbVersion, count }) {
-  return `/**
- * Content types for a response, resolved here rather than pulled in.
- *
- * \`response.type("txt")\` has to become \`text/plain; charset=utf-8\`, which is a
- * lookup table and one charset rule — the same job \`@c9up/archive\` already
- * does in its own table, so the framework was carrying a dependency for work
- * the ecosystem already owned.
- *
- * A hand-written table is what made that a regression rather than a saving:
- * it knew the extensions someone thought of, so \`.yaml\`, \`.sql\`, \`.opus\` and
- * \`.xhtml\` fell through and the caller's own string went out as the content
- * type. The tables below are GENERATED from mime-db instead, which is where
- * \`mime-types\` reads them too, so the resolution is the same one and stays
- * the same one.
- *
- * Regenerate with:
- *
- *     node scripts/generate-mime.mjs
- *
- * Do not edit {@link TYPES} or {@link CHARSETS} by hand.
- *
- * @generated from mime-db ${dbVersion} (${count} extensions)
- */
-
-/** Extension → type. No leading dot; lowercase. */
-const TYPES: Record<string, string> = {
-${rows}
-}
-
-/**
- * Types that declare a charset of their own, lowercased.
- *
- * Everything else under \`text/\` defaults to utf-8; everything else has none.
- * That is mime-db's \`charset\` field plus \`mime-types\`' \`text/*\` fallback.
- */
-const CHARSETS: Record<string, string> = {
-${charsets}
-}
-
-/** The charset for a type, or \`undefined\` when it carries none. */
-function charsetFor(type: string): string | undefined {
-  const base = type.split(';')[0].trim().toLowerCase()
-  const declared = CHARSETS[base]
-  if (declared !== undefined) return declared
-  return base.startsWith('text/') ? 'utf-8' : undefined
-}
-
-/** The type for a bare extension, or \`undefined\` when it is not one we know. */
-export function lookupType(extension: string): string | undefined {
-  const ext = extension.replace(/^.*\\./, '').toLowerCase()
-  return TYPES[ext]
-}
-
-/**
- * A full \`Content-Type\` for an extension or a type (\`mime-types.contentType\`).
- *
- * Returns \`false\` for something it cannot resolve, as the package did, so the
- * caller keeps its existing fallback rather than writing \`content-type: false\`.
- */
-export function contentType(input: string): string | false {
-  if (input.length === 0) return false
-  // Already a type — possibly with parameters the caller set itself.
-  const type = input.includes('/') ? input : lookupType(input)
-  if (type === undefined) return false
-  if (type.includes('charset=')) return type
-  const charset = charsetFor(type)
-  return charset === undefined ? type : \`\${type}; charset=\${charset}\`
-}
-`
-}

package/scripts/generate-napi-types.mjs

@@ -1,187 +0,0 @@
-#!/usr/bin/env node
-/**
- * Generate the TypeScript surface of the native modules FROM the Rust.
- *
- * `napi-derive`'s `type-def` feature emits one JSON line per exported item
- * while cargo compiles. Those lines are the source of truth: they are derived
- * from the `#[napi]` items themselves, so a signature cannot drift from the
- * Rust without this file changing.
- *
- * Hand-written interfaces are what we had before, and they DID drift — making
- * `Bus::on_request` synchronous changed the Rust with nothing on the TypeScript
- * side to notice.
- *
- * One thing napi-rs cannot infer: the shape of a `JsFunction` callback. It
- * emits `(...args: any[]) => any`. Those few are refined below, by name, and
- * the script fails if a refinement no longer matches anything — so the table
- * cannot rot either.
- *
- *   TYPE_DEF_TMP_PATH=<file> cargo build -p <crates…>
- *   node scripts/generate-napi-types.mjs <file> <out.d.ts>
- */
-
-import { readFileSync, writeFileSync } from 'node:fs'
-
-/**
- * Callback signatures napi-rs erases to `any`, restored here.
- *
- * Keyed by `<owner>.<method>`; the value replaces the whole parameter. Every
- * entry must match, or the script fails: a stale refinement is how a hand
- * annotation quietly stops describing the Rust.
- */
-/**
- * napi-derive 3 emits `callback: (arg: unknown) => unknown` where 2 emitted
- * `(...args: any[]) => any` — better, since it no longer reaches for `any`,
- * but a different string to match on. These refinements exist because the
- * generated shape says nothing about what the callback actually receives.
- */
-const CALLBACK_REFINEMENTS = {
-  'EventBus.subscribe': {
-    from: 'callback: (arg: unknown) => unknown',
-    to: 'callback: (eventJson: string) => void',
-  },
-  'EventBus.onRequest': {
-    from: 'callback: (arg: unknown) => unknown',
-    to: 'callback: (eventJson: string, reply: (response: string) => void) => void',
-  },
-  'HyperServer.onRequest': {
-    // Only the argument is named. The `to` used to say
-    // `(request: string) => Promise<string> | string`, which described the
-    // boundary as it was BEFORE it stopped serialising: the Rust hands the
-    // handler a JsObject and awaits a `NapiResponse`, and napi's own output
-    // already said so. The refinement was overwriting a correct shape with a
-    // stale one, and nothing noticed because every caller of `onRequest` was
-    // outside the typecheck.
-    from: 'callback: (arg: unknown) => Promise<NapiResponse>',
-    to: 'callback: (request: Record<string, unknown>) => Promise<NapiResponse>',
-  },
-  'HyperServer.onStreamDisconnect': {
-    from: 'callback: (arg: unknown) => unknown',
-    to: 'callback: (streamId: string) => void',
-  },
-  // The Rust hands over a serialised JsTaskPayload — `{ task_name,
-  // scheduled_for_ms }` renamed to camelCase by serde.
-  'RustScheduler.register': {
-    from: 'callback: (arg: unknown) => unknown',
-    to: 'callback: (invocation: { taskName: string; scheduledForMs: number }) => void',
-  },
-}
-
-const [input, output] = process.argv.slice(2)
-if (!input || !output) {
-  console.error('usage: generate-napi-types.mjs <type-def file> <out.d.ts>')
-  process.exit(2)
-}
-
-const entries = readFileSync(input, 'utf8')
-  .split('\n')
-  .map((l) => l.trim())
-  .filter(Boolean)
-  .map((l) => JSON.parse(l))
-
-const used = new Set()
-
-/** Apply the refinements that belong to `owner`, tracking which ones matched. */
-function refine(owner, body) {
-  let out = body
-  for (const [key, { from, to }] of Object.entries(CALLBACK_REFINEMENTS)) {
-    const [entryOwner] = key.split('.')
-    if (entryOwner !== owner) continue
-    if (out.includes(from)) {
-      out = out.replace(from, to)
-      used.add(key)
-    }
-  }
-  return out
-}
-
-/**
- * JSDoc as emitted by napi-derive, indented to sit above its member.
- *
- * `*` followed by `/` inside the text closes the comment early — a Rust doc
- * example holding a cron expression (`0 *​/5 * * *`) is enough to do it, and
- * the generated file then fails to parse. Escaped rather than stripped, so the
- * example still reads correctly.
- */
-function docBlock(doc, indent = '') {
-  if (!doc) return ''
-  // Escape every `*/` EXCEPT the one that closes the block. A Rust doc example
-  // holding a cron expression (`0 */5 * * *`) closes the comment early
-  // otherwise, and the generated file stops parsing — but escaping the closer
-  // too breaks it just as thoroughly, whether the block spans one line or many.
-  const closer = doc.lastIndexOf('*/')
-  const escaped =
-    closer === -1
-      ? doc
-      : doc.slice(0, closer).replaceAll('*/', '*\\/') + doc.slice(closer)
-  return (
-    escaped
-      .split('\n')
-      .filter((l) => l.length > 0)
-      .map((l) => `${indent}${l}`)
-      .join('\n') + '\n'
-  )
-}
-
-const interfaces = entries.filter((e) => e.kind === 'interface')
-const structs = entries.filter((e) => e.kind === 'struct')
-const impls = new Map(entries.filter((e) => e.kind === 'impl').map((e) => [e.name, e]))
-const fns = entries.filter((e) => e.kind === 'fn')
-
-const out = [
-  '// GENERATED FROM THE RUST — do not edit.',
-  '//',
-  '// Produced by scripts/generate-napi-types.mjs from napi-derive\'s type-def',
-  '// output. Editing this file by hand puts it back where it started: a',
-  '// description that can disagree with the code it describes.',
-  '',
-]
-
-for (const iface of interfaces) {
-  out.push(docBlock(iface.js_doc))
-  out.push(`export interface ${iface.name} {`)
-  for (const line of iface.def.split('\n')) {
-    out.push(line ? `  ${line.trim()}` : '')
-  }
-  out.push('}', '')
-}
-
-for (const struct of structs) {
-  const impl = impls.get(struct.name)
-  out.push(docBlock(struct.js_doc))
-  out.push(`export declare class ${struct.name} {`)
-  if (impl) {
-    for (const line of refine(struct.name, impl.def).split('\n')) {
-      out.push(line ? `  ${line.trim()}` : '')
-    }
-  }
-  out.push('}', '')
-}
-
-for (const fn of fns) {
-  out.push(docBlock(fn.js_doc))
-  // napi-derive emits the whole declaration for a function, unlike a struct
-  // where `def` holds only the members.
-  const declaration = fn.def.trim()
-  // napi-derive 3 emits a bare `function name(...)` where 2 emitted the
-  // signature after the name; concatenating onto the former produced
-  // `function xfunction x(...)`.
-  const rendered = declaration.startsWith('export declare function')
-    ? declaration
-    : declaration.startsWith('function ')
-      ? `export declare ${declaration}`
-      : `export declare function ${fn.name}${declaration}`
-  out.push(`${rendered};`, '')
-}
-
-const stale = Object.keys(CALLBACK_REFINEMENTS).filter((k) => !used.has(k))
-if (stale.length > 0) {
-  console.error(
-    `[napi-types] refinement(s) that matched nothing: ${stale.join(', ')}\n` +
-      '[napi-types] the Rust changed under them — update or remove the entry.',
-  )
-  process.exit(1)
-}
-
-writeFileSync(output, out.join('\n'))
-console.log(`[napi-types] ${output} — ${interfaces.length} interface(s), ${structs.length} class(es), ${fns.length} function(s)`)