Каркас целиком: контейнер, маршрутизатор и конвейер отвечают 200 и 404

// Контейнер, маршрутизатор и конвейер — в подложке, здесь только их типы
type Class = new (...args: any[]) => object;
type Req = { method: string; target: string; headers?: Record<string, string>; body?: string };
type Res = { status: number; body: string };
type Handler = (params: Record<string, string>, query: URLSearchParams, request: Req) => unknown;
type Link = (request: Req, response: Res, next: () => Promise<void>) => Promise<void>;
type Found = { handler: Handler; params: Record<string, string>; query: URLSearchParams } | { handler?: undefined; status: number; allow?: string };
declare function Injectable(options?: { deps?: Class[] }): (value: Class, context: ClassDecoratorContext) => void;
declare function Module(options: { imports?: Class[]; providers?: Class[]; exports?: Class[] }): (value: Class, context: ClassDecoratorContext) => void;
declare class App {
  get<T extends object>(from: Class, token: new (...args: any[]) => T): T;
}
declare class Router {
  add(method: string, pattern: string, handler: Handler): void;
  find(method: string, target: string): Found;
}
declare function runPipeline(chain: Link[], request: Req, response: Res): Promise<void>;

@Injectable()
class NotesRepo {
  #rows = new Map([["1", "купить хлеб"]]);

  byId(id: string) {
    return this.#rows.get(id);
  }
}

@Injectable({ deps: [NotesRepo] })
class NotesService {
  constructor(private readonly repo: NotesRepo) {}

  find(id: string) {
    return this.repo.byId(id);
  }
}

@Module({ providers: [NotesRepo, NotesService] })
class AppModule {}

// Склейка руками: достать сервис, объявить маршрут, отправить запрос
const app = new App();
const notes = app.get(AppModule, NotesService);
const router = new Router();
router.add("GET", "/notes/:id", (params) => notes.find(params.id) ?? "нет такой заметки");

const dispatch: Link = async (request, response) => {
  const found = router.find(request.method, request.target);
  if (found.handler === undefined) {
    response.status = found.status;
    response.body = "нет такого адреса";
    return;
  }
  response.status = 200;
  response.body = String(await found.handler(found.params, found.query, request));
};

async function main() {
  for (const request of [
    { method: "GET", target: "/notes/1" },
    { method: "GET", target: "/notes/99" },
    { method: "GET", target: "/health" },
  ]) {
    const response: Res = { status: 404, body: "нет такого адреса" };
    await runPipeline([dispatch], request, response);
    console.log(`${request.method} ${request.target} → ${response.status} ${response.body}`);
  }
}

main();

// Реестр зависимостей depsOf — из подложки: его заполнял @Injectable
type Class = new (...args: any[]) => object;
declare const depsOf: WeakMap<Function, Class[]>;

const prefixes = new WeakMap<Function, string>();
const routes = new WeakMap<Function, { method: string; path: string }>();

function Controller(prefix: string, options: { deps?: Class[] } = {}) {
  return function (value: Class, context: ClassDecoratorContext) {
    prefixes.set(value, prefix);
    depsOf.set(value, options.deps ?? []);
  };
}

// Одно тело на все способы запроса: @Get, @Post и @Delete отличаются одной строкой
const mapping = (method: string) => (path = "") =>
  function (handler: Function, context: ClassMethodDecoratorContext) {
    routes.set(handler, { method, path });
  };

const Get = mapping("GET");
const Post = mapping("POST");
const Delete = mapping("DELETE");

class NotesService {}

@Controller("/notes", { deps: [NotesService] })
class NotesController {
  @Get("/:id")
  byId(req: { params: Record<string, string> }) {
    return `заметка ${req.params.id}`;
  }

  @Post()
  create(req: { body: string }) {
    return `создана ${req.body}`;
  }

  @Delete("/:id")
  remove(req: { params: Record<string, string> }) {
    return `удалена ${req.params.id}`;
  }

  format(title: string) {
    return `«${title}»`;
  }
}

function printRoutes(controller: Function) {
  const proto = controller.prototype;
  for (const name of Object.getOwnPropertyNames(proto)) {
    const route = routes.get(proto[name]);
    if (route === undefined) continue;
    console.log(`${route.method} ${prefixes.get(controller)}${route.path} → ${controller.name}.${name}`);
  }
}

printRoutes(NotesController);
console.log(depsOf.get(NotesController)?.map((dep) => dep.name));

type Class = new (...args: any[]) => object;

const routes = new WeakMap<Function, string>();

function Get(path: string) {
  return function (handler: Function, context: ClassMethodDecoratorContext) {
    routes.set(handler, path);
  };
}

// Тот же bound из главы про декораторы: инициализатор кладёт в экземпляр привязанную копию
function bound(method: Function, context: ClassMethodDecoratorContext) {
  context.addInitializer(function () {
    Object.defineProperty(this, context.name, { value: method.bind(this) });
  });
}

class NotesController {
  #store = new Map([["1", "купить хлеб"]]);

  @Get("/:id")
  @bound
  byId(id: string) {
    return this.#store.get(id) ?? "нет такой заметки";
  }
}

const cls: Class = NotesController;
const instance = new cls();
const name = "byId";

console.log(routes.get(cls.prototype[name]));
console.log(Object.getOwnPropertyNames(instance));

for (const source of [cls.prototype, instance]) {
  const handler = Reflect.get(source, name);
  try {
    console.log(handler("1"));
  } catch (err) {
    console.log(`${(err as Error).name}: вызов без this`);
  }
}

// Контейнер, маршрутизатор, реестр маршрутов и декораторы каркаса — в подложке, здесь их типы
type Class = new (...args: any[]) => object;
type Req = { method: string; target: string; body?: string };
type Handler = (params: Record<string, string>, query: URLSearchParams, request: Req) => unknown;
type Options = { imports?: Class[]; providers?: Class[]; exports?: Class[]; controllers?: Class[] };
type Deco = (value: Class, context: ClassDecoratorContext) => void;
type MethodDeco = (handler: Function, context: ClassMethodDecoratorContext) => void;
declare const depsOf: WeakMap<Function, Class[]>, moduleOf: WeakMap<Function, Options>;
declare const prefixes: WeakMap<Function, string>, routes: WeakMap<Function, { method: string; path: string }>;
declare function Injectable(options?: { deps?: Class[] }): Deco;
declare function Module(options: Options): Deco;
declare function Controller(prefix: string, options?: { deps?: Class[] }): Deco;
declare function Get(path?: string): MethodDeco;
declare function Post(path?: string): MethodDeco;
declare class App {
  get<T extends object>(from: Class, token: new (...args: any[]) => T): T;
}
declare class Router {
  add(method: string, pattern: string, handler: Handler): void;
  find(method: string, target: string): { handler: Handler; params: Record<string, string>; query: URLSearchParams } | { handler?: undefined; status: number };
}

// Корень и всё, что он ввозит, вглубь: перебор растущего массива добирает ввоз ввезённых
function modulesOf(root: Class) {
  const list = [root];
  for (const mod of list) {
    for (const imported of moduleOf.get(mod)?.imports ?? []) {
      if (!list.includes(imported)) list.push(imported);
    }
  }
  return list;
}

function register(app: App, router: Router, root: Class) {
  for (const mod of modulesOf(root)) {
    for (const cls of moduleOf.get(mod)?.controllers ?? []) {
      const deps = depsOf.get(cls);
      if (!deps) throw new Error(`${cls.name} не помечен @Controller`);
      // контроллер создаёт тот же контейнер, но в контейнере не лежит: его никто не внедряет
      const instance = new cls(...deps.map((dep) => app.get(mod, dep)));
      for (const name of Object.getOwnPropertyNames(cls.prototype)) {
        const route = routes.get(cls.prototype[name]);
        if (route === undefined) continue;
        const handler = Reflect.get(instance, name);
        const pattern = `${prefixes.get(cls)}${route.path}`;
        console.log(`${route.method} ${pattern} → ${cls.name}.${name} из ${mod.name}`);
        router.add(route.method, pattern, (params, query, request) =>
          handler.call(instance, { params, query, body: request.body }));
      }
    }
  }
}

@Injectable()
class Clock {
  today() {
    return "22.09";
  }
}

@Controller("/time", { deps: [Clock] })
class TimeController {
  constructor(private readonly clock: Clock) {}

  @Get()
  now() {
    return this.clock.today();
  }
}

@Module({ providers: [Clock], exports: [Clock], controllers: [TimeController] })
class ClockModule {}

@Injectable({ deps: [Clock] })
class NotesService {
  constructor(private readonly clock: Clock) {}

  find(id: string) {
    return `заметка ${id} от ${this.clock.today()}`;
  }
}

@Controller("/notes", { deps: [NotesService] })
class NotesController {
  constructor(private readonly notes: NotesService) {}

  @Get("/:id")
  byId(req: { params: Record<string, string> }) {
    return this.notes.find(req.params.id);
  }
}

@Module({ imports: [ClockModule], providers: [NotesService], controllers: [NotesController] })
class NotesModule {}

@Controller("/health")
class HealthController {
  @Get()
  ping() {
    return "жив";
  }
}

@Module({ imports: [NotesModule], controllers: [HealthController] })
class AppModule {}

const app = new App();
const router = new Router();
register(app, router, AppModule);

const found = router.find("GET", "/notes/7");
if (found.handler !== undefined) console.log(found.handler(found.params, found.query, { method: "GET", target: "/notes/7" }));

// Контейнер, маршрутизатор и конвейер — в подложке, здесь только их типы
type Class = new (...args: any[]) => object;
type Req = { method: string; target: string; headers?: Record<string, string>; body?: string };
type Res = { status: number; body: string };
type Call = { params: Record<string, string>; query: URLSearchParams; body: string };
type Handler = (params: Record<string, string>, query: URLSearchParams, request: Req) => unknown;
type Link = (request: Req, response: Res, next: () => Promise<void>) => Promise<void>;
type Found = { handler: Handler; params: Record<string, string>; query: URLSearchParams } | { handler?: undefined; status: number; allow?: string };
type Options = { imports?: Class[]; providers?: Class[]; exports?: Class[]; controllers?: Class[] };
declare const depsOf: WeakMap<Function, Class[]>, moduleOf: WeakMap<Function, Options>;
declare function Injectable(options?: { deps?: Class[] }): (value: Class, context: ClassDecoratorContext) => void;
declare function Module(options: Options): (value: Class, context: ClassDecoratorContext) => void;
declare class App {
  get<T extends object>(from: Class, token: new (...args: any[]) => T): T;
}
declare class Router {
  add(method: string, pattern: string, handler: Handler): void;
  find(method: string, target: string): Found;
}
declare function runPipeline(chain: Link[], request: Req, response: Res): Promise<void>;

// Реестр каркаса: у класса — префикс пути, у функции-обработчика — способ и путь
const prefixes = new WeakMap<Function, string>();
const routes = new WeakMap<Function, { method: string; path: string }>();

// @Controller делает две записи: путь контроллера и список зависимостей — как @Injectable
function Controller(prefix: string, options: { deps?: Class[] } = {}) {
  return function (value: Class, context: ClassDecoratorContext) {
    prefixes.set(value, prefix);
    depsOf.set(value, options.deps ?? []);
  };
}

// Одно тело на @Get, @Post и @Delete: способ запроса разный, запись одна
const mapping = (method: string) => (path = "") =>
  function (handler: Function, context: ClassMethodDecoratorContext) {
    routes.set(handler, { method, path });
  };

const Get = mapping("GET");
const Post = mapping("POST");
const Delete = mapping("DELETE");

// Ошибка, которую каркас понимает и переводит в ответ; всё остальное для него — 500
class HttpError extends Error {
  constructor(
    readonly status: number,
    message: string,
  ) {
    super(message);
  }
}

// Корень и всё, что он ввозит, вглубь: перебор растущего массива добирает ввоз ввезённых
function modulesOf(root: Class) {
  const list = [root];
  for (const mod of list) {
    for (const imported of moduleOf.get(mod)?.imports ?? []) {
      if (!list.includes(imported)) list.push(imported);
    }
  }
  return list;
}

function createApp(root: Class, chain: Link[] = []) {
  const app = new App();
  const router = new Router();
  for (const mod of modulesOf(root)) {
    for (const cls of moduleOf.get(mod)?.controllers ?? []) {
      const deps = depsOf.get(cls);
      if (!deps) throw new Error(`${cls.name} не помечен @Controller`);
      // контроллер создаёт тот же контейнер, но в контейнере не лежит: его никто не внедряет
      const instance = new cls(...deps.map((dep) => app.get(mod, dep)));
      for (const name of Object.getOwnPropertyNames(cls.prototype)) {
        const route = routes.get(cls.prototype[name]);
        if (route === undefined) continue;
        // обработчик берётся у объекта, а не у прототипа: собственное свойство экземпляра главнее
        const handler = Reflect.get(instance, name);
        router.add(route.method, `${prefixes.get(cls)}${route.path}`, (params, query, request) =>
          handler.call(instance, { params, query, body: request.body ?? "" }));
      }
    }
  }

  // маршрутизатор — последнее звено конвейера, обработчик контроллера — за ним
  const dispatch: Link = async (request, response) => {
    const found = router.find(request.method, request.target);
    if (found.handler === undefined) {
      response.status = found.status;
      response.body = found.allow ? `Allow: ${found.allow}` : "нет такого адреса";
      return;
    }
    response.status = 200;
    response.body = String(await found.handler(found.params, found.query, request));
  };

  // ловец каркас ставит сам, перед отправкой: ваши звенья остаются снаружи него
  const catcher: Link = async (request, response, next) => {
    try {
      await next();
    } catch (err) {
      const known = err instanceof HttpError;
      response.status = known ? err.status : 500;
      response.body = known ? err.message : "внутренняя ошибка";
    }
  };

  return {
    async inject(request: Req) {
      const response: Res = { status: 404, body: "нет такого адреса" };
      await runPipeline([...chain, catcher, dispatch], request, response);
      return response;
    },
  };
}

@Injectable()
class NotesRepo {
  #rows = new Map([["1", "купить хлеб"]]);

  byId(id: string) {
    return this.#rows.get(id);
  }

  add(text: string) {
    const id = String(this.#rows.size + 1);
    this.#rows.set(id, text);
    return id;
  }
}

@Injectable({ deps: [NotesRepo] })
class NotesService {
  constructor(private readonly repo: NotesRepo) {}

  find(id: string) {
    const text = this.repo.byId(id);
    if (text === undefined) throw new HttpError(404, "нет такой заметки");
    return text;
  }

  create(title: string) {
    return this.repo.add(title);
  }
}

@Controller("/notes", { deps: [NotesService] })
class NotesController {
  constructor(private readonly notes: NotesService) {}

  @Get("/:id")
  byId(call: Call) {
    return this.notes.find(call.params.id);
  }

  @Post()
  create(call: Call) {
    return `создана ${this.notes.create(JSON.parse(call.body).title)}`;
  }
}

@Module({ providers: [NotesRepo, NotesService], controllers: [NotesController] })
class AppModule {}

const journal: Link = async (request, response, next) => {
  await next();
  console.log(`${request.method} ${request.target} → ${response.status} ${response.body}`);
};

const app = createApp(AppModule, [journal]);

async function main() {
  await app.inject({ method: "GET", target: "/notes/1" });
  await app.inject({ method: "GET", target: "/notes/99" });
  await app.inject({ method: "POST", target: "/notes", body: '{"title":"каркас готов"}' });
  await app.inject({ method: "DELETE", target: "/notes/1" });
  await app.inject({ method: "GET", target: "/health" });
  await app.inject({ method: "POST", target: "/notes", body: "не json" });
}

main();