wtclaude
5d7668d5ea
The first real module. It registers nothing, deliberately: what slice 0 proves
is the delivery path itself, end to end, before a single UO file moves into it.
Server half: module.json, an entry point that takes (ctx, api) and registers
nothing, a test suite built on a fake ctx, and scripts/checkImports.js -- the
MODULE_API.md §5.1 boundary check. Client half: the Vite library build, four
shims re-exporting react / react-dom/client / react-router-dom / jsx-runtime
from window.__rg, an entry that verifies each is identity-equal to core's copy,
and scripts/checkExternals.js. 29 server tests, 9 client tests, both new.
Verified against a real core: the module loads, mounts its zero routes, runs to
`started`, and is published by /api/v1/public/modules. Its chunk serves from
the entry's directory with `Cache-Control: no-cache` while the module's server
source, module.json and package.json all 404. In Chrome, under the enforced
`script-src 'self'`, the chunk evaluates and reports all four shared
dependencies OK, with zero CSP reports and no console errors.
Three findings, each of which had produced a green build that was wrong.
MODULE_API.md §3.6 shows `external` alongside the aliases and they do not
compose. Rollup asks `external` BEFORE Vite's alias resolver runs, so a
specifier in both is marked external and never aliased -- the chunk then ships
bare `import "react"`, which no browser can resolve without an import map, and
CSP forbids one. Built cleanly and emitted exactly that; checkExternals caught
it. So: alias only, `external` empty, and vite.config.js grows a resolution-time
guard that fails the build if a shared dependency resolves into node_modules.
That guard was wrong twice before it worked. Written against Rollup's `load`
hook it never ran -- `load` is first-wins and an earlier plugin had already
claimed the module -- so a deliberately-broken alias produced a 24 kB chunk with
react-router welded in, and a green build. And its forbidden-package list was
derived from the alias list "so the two cannot disagree", which meant deleting
an alias also deleted the guard against what that alias prevented. It states the
contract now, and a test asserts the aliases stay inside it.
checkImports failed on its own documentation the first time it ran: the comment
naming require("../../etc/passwd") as an example of what to catch, and index.js
explaining why the module must never require("express"). A boundary check that
cannot survive being described is one people stop writing comments around. It
strips comments and template literals with a character walk rather than a
regexp, because a URL in a string contains a comment opener and a comment
contains quotes -- and it has its own test suite, since a check never shown to
fail is a check nobody knows the state of.
Co-Authored-By: Claude <noreply@anthropic.com>
82 lines
3.5 KiB
JavaScript
82 lines
3.5 KiB
JavaScript
// `module.json` is what core validates before it will load anything, and every
|
|
// rule it is checked against lives in core's loader (MODULE_API.md §2.1, §4.3).
|
|
// Restating those rules here means a manifest mistake fails in this repo's CI,
|
|
// which can say what is wrong, rather than on an install, where the symptom is a
|
|
// module that is simply absent.
|
|
//
|
|
// These are the loader's own patterns, copied deliberately rather than imported:
|
|
// this repo has no dependency on core's source, and a copy that drifts is
|
|
// exactly what the coreApi range exists to catch.
|
|
|
|
const test = require('node:test')
|
|
const assert = require('node:assert')
|
|
const fs = require('node:fs')
|
|
const path = require('node:path')
|
|
|
|
const ROOT = path.resolve(__dirname, '..', '..')
|
|
const manifest = JSON.parse(fs.readFileSync(path.join(ROOT, 'module.json'), 'utf8'))
|
|
|
|
const KEYS = new Set([
|
|
'id', 'name', 'version', 'coreApi', 'server', 'client',
|
|
'schema', 'purge', 'mounts', 'extensions', 'capabilities',
|
|
])
|
|
const ID = /^[a-z][a-z0-9-]{1,31}$/
|
|
const PREFIX = /^\/[a-z0-9][a-z0-9-]*$/
|
|
const TIERS = ['public', 'admin', 'player']
|
|
|
|
test('declares no key core would reject', () => {
|
|
for (const key of Object.keys(manifest)) {
|
|
assert.ok(KEYS.has(key), `unknown key "${key}" — core rejects rather than ignores it`)
|
|
}
|
|
})
|
|
|
|
test('id is "uo" and matches the directory it installs as', () => {
|
|
assert.ok(ID.test(manifest.id))
|
|
assert.strictEqual(manifest.id, 'uo')
|
|
})
|
|
|
|
test('version and coreApi are present and semver-shaped', () => {
|
|
assert.match(manifest.version, /^\d+\.\d+\.\d+/)
|
|
assert.match(manifest.coreApi, /^[\^~]?\d+\.\d+\.\d+/)
|
|
})
|
|
|
|
test('every declared file exists', () => {
|
|
for (const key of ['server', 'schema', 'purge']) {
|
|
if (manifest[key]) {
|
|
assert.ok(fs.existsSync(path.join(ROOT, manifest[key])), `${key}: ${manifest[key]} is missing`)
|
|
}
|
|
}
|
|
})
|
|
|
|
test('a schema fragment always comes with a purge', () => {
|
|
// Core enforces this too. A module that can create tables and cannot drop them
|
|
// leaves an operator with orphaned data and no supported way to remove it.
|
|
if (manifest.schema) assert.ok(manifest.purge, 'declares schema but no purge')
|
|
})
|
|
|
|
test('client.entry is in a subdirectory, because its directory is what gets served', () => {
|
|
assert.ok(manifest.client, 'module-uo ships a client half')
|
|
const entry = manifest.client.entry
|
|
assert.match(path.basename(entry), /^[A-Za-z0-9][A-Za-z0-9._-]*\.js$/)
|
|
// The rule worth a test of its own: core serves `dirname(entry)`, so an entry
|
|
// in the module root would publish the server source and module.json.
|
|
assert.notStrictEqual(path.dirname(path.resolve(ROOT, entry)), ROOT)
|
|
assert.ok(path.resolve(ROOT, entry).startsWith(ROOT + path.sep), 'entry escapes the module root')
|
|
})
|
|
|
|
test('declared mounts are single lowercase segments in known tiers', () => {
|
|
for (const [tier, prefixes] of Object.entries(manifest.mounts || {})) {
|
|
assert.ok(TIERS.includes(tier), `unknown tier "${tier}"`)
|
|
for (const prefix of prefixes) assert.match(prefix, PREFIX)
|
|
}
|
|
})
|
|
|
|
test('notification stream ids and announce legs stay namespaced or grandfathered', () => {
|
|
// Nothing to check yet — slice 0 registers neither. The assertion that matters
|
|
// is that the manifest does not quietly claim capabilities the module does not
|
|
// serve, since `GET /api/v1/public/modules` publishes them to clients.
|
|
assert.deepStrictEqual(manifest.capabilities || [], [])
|
|
assert.deepStrictEqual(manifest.mounts || {}, {})
|
|
assert.deepStrictEqual(manifest.extensions || [], [])
|
|
})
|