mirror of
https://github.com/nexu-io/open-design.git
synced 2026-06-01 03:14:35 +07:00
aa0616062d
* refactor(daemon): introduce HTTP Request Adapter + typed Deps (proof on active-context-routes)
Adds a typed HTTP boundary Adapter under apps/daemon/src/http/ that replaces
the untyped ServerContext service-locator pattern (30+ fields, mostly any)
for route handlers. Routes become pure (input, deps) -> Result<output>
functions, unit-testable without Express or supertest.
Six new modules under apps/daemon/src/http/:
- types.ts Result<T,E>, ok(), err(), JsonRouteSpec, Handler,
RouteInputContext, HttpMethod, InputParser
- parse.ts rawInput(req), validationError(message, issues?)
- response.ts sendJson(), sendApiError(), statusForError() +
ERROR_STATUS_BY_CODE map
- origin-guard.ts guardSameOrigin(req, origin) wrapping isLocalSameOrigin
as a Result
- adapter.ts defineJsonRoute(), mountJsonRoute() (only place that
knows about req/res)
- index.ts barrel
active-context-routes.ts migrated as proof of pattern. parsePostActive(),
handlePostActive(), handleGetActive() are now pure functions; postActiveRoute
and getActiveRoute are exported route specs. The wire signature
registerActiveContextRoutes(app, ctx) is preserved so server.ts is untouched.
Spec at specs/current/daemon-http-adapter.md captures the strangler migration
order for the remaining route files (mcp-routes, chat-routes, artifact
routes, etc.) and a StreamRoute follow-up where the Run Orchestrator lands.
Wire-format note: cross-origin response moves from the legacy
{ error: 'cross-origin request rejected' } shape to the structured
{ error: { code: 'FORBIDDEN', message: ... } } shape. Backwards-compatible
via the existing CompatibleErrorResponse = ApiErrorResponse | LegacyErrorResponse
union in @open-design/contracts.
Validation:
- pnpm install (post-rebase, exit 0)
- pnpm --filter @open-design/daemon typecheck (both tsconfig.json and
tsconfig.tests.json silent => pass)
- pnpm --filter @open-design/daemon test: 15 new tests pass
(tests/http/adapter.test.ts + tests/active-context-routes.test.ts).
84 pre-existing failures across 23 files are unchanged and unrelated
to this PR (Windows symlink / short-name / colon-in-filename, upstream
behavior drift, missing plugin marketplace fixtures, and a freshly-
added tools-connectors-cli suite of 38 failures that landed during
the rebase).
Sharpens W4/W5 of specs/current/maintainability-roadmap.md and unlocks
W6 (Run Orchestrator).
* chore: add core-js, electron-winstaller, protobufjs, sharp to pnpm.onlyBuiltDependencies
59 lines
2.1 KiB
TypeScript
59 lines
2.1 KiB
TypeScript
import type { Express, Request, Response } from 'express';
|
|
import { createApiError } from '@open-design/contracts';
|
|
import { rawInput } from './parse.js';
|
|
import { sendApiError, sendJson, statusForError } from './response.js';
|
|
import { guardSameOrigin, type OriginContext } from './origin-guard.js';
|
|
import type { JsonRouteSpec } from './types.js';
|
|
|
|
export interface AdapterContext extends OriginContext {}
|
|
|
|
/**
|
|
* Identity function that pins a route spec's generic parameters at the
|
|
* definition site so callers do not have to repeat them. The returned spec
|
|
* is consumed by `mountJsonRoute` (live) and by tests (direct invocation of
|
|
* `route.parse` / `route.handle`).
|
|
*/
|
|
export function defineJsonRoute<Input, Output, Deps>(
|
|
spec: JsonRouteSpec<Input, Output, Deps>,
|
|
): JsonRouteSpec<Input, Output, Deps> {
|
|
return spec;
|
|
}
|
|
|
|
/**
|
|
* Mounts one JsonRouteSpec on an Express app. The Adapter is the only code
|
|
* here that knows about req/res; the route's parse and handle functions
|
|
* operate on `RouteInputContext` and `Deps` respectively, so they are unit
|
|
* testable without Express.
|
|
*/
|
|
export function mountJsonRoute<Input, Output, Deps>(
|
|
app: Express,
|
|
spec: JsonRouteSpec<Input, Output, Deps>,
|
|
deps: Deps,
|
|
adapter: AdapterContext,
|
|
): void {
|
|
app[spec.method](spec.path, async (req: Request, res: Response) => {
|
|
try {
|
|
if (spec.requireSameOrigin) {
|
|
const origin = guardSameOrigin(req, adapter);
|
|
if (!origin.ok) {
|
|
sendApiError(res, statusForError(origin.error), origin.error);
|
|
return;
|
|
}
|
|
}
|
|
const parsed = spec.parse(rawInput(req));
|
|
if (!parsed.ok) {
|
|
sendApiError(res, statusForError(parsed.error), parsed.error);
|
|
return;
|
|
}
|
|
const result = await spec.handle(parsed.value, deps);
|
|
if (!result.ok) {
|
|
sendApiError(res, statusForError(result.error), result.error);
|
|
return;
|
|
}
|
|
sendJson(res, spec.successStatus ?? 200, result.value);
|
|
} catch (e) {
|
|
const message = e instanceof Error ? e.message : String(e);
|
|
sendApiError(res, 500, createApiError('INTERNAL_ERROR', message));
|
|
}
|
|
});
|
|
}
|