wtclaude
bf470c7658
THROWAWAY BRANCH — evidence for the Phase 1 contract, never merged. See
modules/uo/SPIKE.md and docs/website/MODULE_API.md Part 7.
The six public spawn-atlas routes now live in modules/uo/, reached only through
the ctx/register surface, with the client half loading as a prebuilt ESM chunk.
All three exit criteria met:
• zero internal-file imports from the module into core; the built chunk has
zero bare import specifiers and bundles no React
• routes.manifest.json AND routes.guards.json are byte-identical
• /uo/atlas renders from /modules/uo/entry.js under script-src 'self' with
zero CSP violation reports
729 core tests and 81 module tests pass. Verified end to end against the real
database: the schema fragment replays after core's, onBoot runs the atlas
refresh, and the six API URLs answer unchanged.
Two things the spike changed in the contract:
• ctx.express / ctx.validator. A module lives outside server/, so Node never
reaches server/node_modules and require('express') fails outright — the
server-side twin of the one-React rule, which §2.6 had only for the client.
• window.__rg.jsxRuntime, so a module can build with the automatic JSX
runtime its tooling already assumes rather than being forced to classic.
And it confirmed §6.1 empirically: regenerating the OpenAPI spec silently
deleted all 361 lines of the atlas paths with "Swagger-autogen: Success", while
the route manifest kept all six in the same run. That is exactly the
static-analysis-vs-runtime split the fragment merge exists to prevent.
Co-Authored-By: Claude <noreply@anthropic.com>
89 lines
3.7 KiB
JavaScript
89 lines
3.7 KiB
JavaScript
// ── The module's single point of contact with core ─────────────────────────
|
|
//
|
|
// Every other file in this module imports THIS file instead of reaching into
|
|
// the website's tree. That is the whole mechanical trick behind the
|
|
// zero-internal-imports rule (docs/website/MODULE_API.md §5.1): the moved files
|
|
// changed by one `require` line each, and a CI grep for a relative path
|
|
// escaping the module root can then be an exact test rather than a heuristic.
|
|
//
|
|
// It exists because `ctx` arrives as an ARGUMENT to register(), while the files
|
|
// that need it are plain CommonJS modules that were written against top-level
|
|
// requires. Rather than thread ctx through nine constructors, register() parks
|
|
// it here once and everything else reads it lazily.
|
|
//
|
|
// Lazily is load-bearing: this file is required at module-require time, which is
|
|
// during app.js's own require, and reading `ctx.db` eagerly would rebuild the
|
|
// startup-time database dependency the loader is careful not to have.
|
|
|
|
let ctx = null
|
|
|
|
/** Called exactly once, by server/index.js, at the top of register(). */
|
|
function init(next) {
|
|
if (ctx) throw new Error('module-uo: core.init() called twice')
|
|
ctx = next
|
|
}
|
|
|
|
function require_() {
|
|
if (!ctx) throw new Error('module-uo: core used before register() ran')
|
|
return ctx
|
|
}
|
|
|
|
// Forwarders rather than re-exports: `const { query } = require('./core')`
|
|
// destructures at require time, which is before init(), so a plain re-export
|
|
// would capture undefined. Each of these resolves ctx at CALL time.
|
|
const query = (sql, params) => require_().db.query(sql, params)
|
|
|
|
const logger = (namespace) => require_().log(namespace)
|
|
|
|
const settings = {
|
|
get: (key) => require_().settings.get(key),
|
|
// `updatedBy` is the third parameter core's settings.model.set carries — the
|
|
// atlas path setter passes it (shardAtlas.model.js:60), so dropping it here
|
|
// would silently lose the audit attribution rather than fail.
|
|
set: (key, value, updatedBy) => require_().settings.set(key, value, updatedBy),
|
|
getInstanceName: () => require_().settings.getInstanceName(),
|
|
}
|
|
|
|
const auth = {
|
|
getUserFromRequest: (req) => require_().auth.getUserFromRequest(req),
|
|
}
|
|
|
|
const middleware = {
|
|
siteMode: (req, res, next) => require_().middleware.siteMode(req, res, next),
|
|
validate: (req, res, next) => require_().middleware.validate(req, res, next),
|
|
requireAuth: (req, res, next) => require_().middleware.requireAuth(req, res, next),
|
|
noindex: (req, res, next) => require_().middleware.noindex(req, res, next),
|
|
requireRole: (...roles) => {
|
|
// requireRole is a FACTORY, so it must be resolved at call time and the
|
|
// resulting middleware kept — resolving it per request would build a new
|
|
// closure on every hit.
|
|
let built = null
|
|
return (req, res, next) => {
|
|
built = built || require_().middleware.requireRole(...roles)
|
|
return built(req, res, next)
|
|
}
|
|
},
|
|
}
|
|
|
|
module.exports = {
|
|
init,
|
|
// Shared server dependencies, taken from core rather than required directly.
|
|
// A module lives outside server/, so `require('express')` from here does not
|
|
// resolve at all — and even where it did, a second express in the process
|
|
// would be a second Router prototype. Same rule as React on the client.
|
|
get express() { return require_().express },
|
|
get validator() { return require_().validator },
|
|
query,
|
|
logger,
|
|
settings,
|
|
auth,
|
|
middleware,
|
|
get pool() { return require_().db.pool },
|
|
get secretBox() { return require_().secretBox },
|
|
get push() { return require_().push },
|
|
get uploads() { return require_().uploads },
|
|
get posts() { return require_().posts },
|
|
get paths() { return require_().paths },
|
|
get moduleId() { return require_().moduleId },
|
|
}
|