Домен целиком: ваш каркас обслуживает настоящие сценарии

// apps/api/src/notes/notes.router.ts боевого API учебника, выдержка
@Query({ input: listInput, output: noteListOutput })
list(@Ctx() ctx: IAppContext, @Input() input: ListInput) {
  return this.notesService.list(input, ctx.userId ?? null);
}

// Автор берётся из токена, а не из входа: иначе заметку можно было бы
// подписать чужим именем
@Mutation({ input: createNoteInput, output: noteOutput })
@UseMiddlewares(AuthMiddleware)
create(@Ctx() ctx: IAuthedContext, @Input() input: CreateNoteInput) {
  return this.notesService.create(ctx.userId, input);
}

type Status = "draft" | "published";
type User = { id: number; email: string; passwordHash: string; name: string; role: "user" | "admin" };
type Note = { id: number; authorId: number; title: string; body: string; status: Status; createdAt: number };
// Форма ответа перечислена здесь: строка таблицы сама в неё не превращается
type NoteOut = { id: number; title: string; body: string; status: Status; author: string };
// В правку не входит автор: переписать владельца строки нечем
type NotePatch = { title?: string; body?: string; status?: Status };

// Движок главы 9 — на подложке; строки у него нетипизированные, тип начинается здесь
declare class Table<Row extends { id: number }> {
  index(name: string, column: string, options?: { unique?: boolean }): Table<Row>;
  insert(values: Omit<Row, "id">): Row;
  update(id: number, patch: Partial<Row>): Row | null;
  where(match: (row: Row) => boolean): Row[];
}

const PAGE = 3;
const day = (n: number): number => Date.UTC(2026, 8, n);

// Провайдер общего модуля: две таблицы проекта и те же строки, что лежат
// в базе после первой миграции
class Db {
  users = new Table<User>().index("users_email_key", "email", { unique: true });
  notes = new Table<Note>().index("notes_author_idx", "authorId");

  constructor() {
    for (const name of ["Аня", "Боб"])
      this.users.insert({ email: `${name}@example.com`, passwordHash: "pbkdf2$600000$…", name, role: "user" });
    const rows: [number, string, Status, number][] = [
      [1, "Хлеб и молоко", "published", 18],
      [1, "План побега", "draft", 19],
      [2, "Отчёт за март", "published", 20],
      [2, "Ремонт кухни", "draft", 21],
      [1, "Идеи на лето", "published", 22],
    ];
    for (const [authorId, title, status, n] of rows)
      this.notes.insert({ authorId, title, body: "", status, createdAt: day(n) });
  }
}

class NotesRepo {
  #db: Db;

  constructor(db: Db) {
    this.#db = db;
  }

  // Условие видимости — одно на список и на карточку: вторая дверь
  // к строкам всегда пишется позже первой, и правило в неё не переезжает
  #visible(viewer: number, row: Note): boolean {
    return row.status === "published" || row.authorId === viewer;
  }

  // Второй ключ порядка — номер строки: без него правка сдвигает страницы
  page(viewer: number, n: number): NoteOut[] {
    const rows = this.#db.notes
      .where((row) => this.#visible(viewer, row))
      .sort((a, b) => b.createdAt - a.createdAt || b.id - a.id);
    return this.#out(rows.slice(n * PAGE, n * PAGE + PAGE));
  }

  byId(viewer: number, id: number): NoteOut | null {
    const found = this.#db.notes.where((row) => row.id === id && this.#visible(viewer, row));
    return found.length === 0 ? null : this.#out(found)[0];
  }

  create(authorId: number, input: { title: string; body: string }): NoteOut {
    const row = this.#db.notes.insert({ ...input, authorId, status: "draft", createdAt: day(23) });
    return this.#out([row])[0];
  }

  // Владелец — часть условия правки, а не проверка перед ней
  update(viewer: number, id: number, patch: NotePatch): NoteOut | null {
    const found = this.#db.notes.where((row) => row.id === id && row.authorId === viewer);
    if (found.length === 0) return null;
    return this.#out([this.#db.notes.update(id, patch)!])[0];
  }

  // Имена авторов — одной выборкой на страницу, а не по одной на строку
  #out(rows: Note[]): NoteOut[] {
    const ids = new Set(rows.map((row) => row.authorId));
    const names = new Map(this.#db.users.where((row) => ids.has(row.id)).map((row) => [row.id, row.name]));
    return rows.map((row) => ({ id: row.id, title: row.title, body: row.body, status: row.status, author: names.get(row.authorId)! }));
  }
}

const repo = new NotesRepo(new Db());
const titles = (rows: NoteOut[]): string => rows.map((row) => row.title).join(" | ");

console.log("гость:", titles(repo.page(0, 0)));
console.log("Аня:  ", titles(repo.page(1, 0)));
console.log("Боб:  ", titles(repo.page(2, 0)));
console.log("Боб открыл /notes/2:", repo.byId(2, 2)?.title ?? "нет такой");
console.log("Аня открыла /notes/2:", repo.byId(1, 2)?.title ?? "нет такой");
console.log("Боб правит /notes/2:", repo.update(2, 2, { title: "Моё" })?.title ?? "нет такой");
console.log("Аня создала заметку, вышло:", repo.create(1, { title: "Список покупок", body: "" }).status);
console.log("Аня теперь:", titles(repo.page(1, 0)));
console.log("Боб теперь:", titles(repo.page(2, 0)));
console.log("в ответе поля:", Object.keys(repo.byId(1, 1)!).join(", "));

type Status = "draft" | "published";
type NoteOut = { id: number; title: string; body: string; status: Status; author: string };
type NotePatch = { title?: string; body?: string; status?: Status };

// Таблицы проекта и репозиторий прошлого раздела — на подложке
declare class Db {}
declare class NotesRepo {
  constructor(db: Db);
  page(viewer: number, n: number): NoteOut[];
  byId(viewer: number, id: number): NoteOut | null;
  create(authorId: number, input: { title: string; body: string }): NoteOut;
  update(viewer: number, id: number, patch: NotePatch): NoteOut | null;
}
// Доменный отказ из главы 6: код, и ни слова про HTTP
declare class DomainError extends Error {
  readonly code: string;
}
declare function fail(code: string, detail?: string): never;

class NotesService {
  #repo: NotesRepo;

  constructor(repo: NotesRepo) {
    this.#repo = repo;
  }

  page(viewer: number, n: number): NoteOut[] {
    return this.#repo.page(viewer, n);
  }

  // «Нет такой» — тоже правило домена, а не пустой ответ
  byId(viewer: number, id: number): NoteOut {
    return this.#repo.byId(viewer, id) ?? fail("NOT_FOUND", `заметка ${id}`);
  }

  create(authorId: number, input: { title: string; body: string }): NoteOut {
    return this.#repo.create(authorId, input);
  }

  /*
   * Правка не нашла строку по двум разным причинам, и ответ у них разный.
   * Второй вопрос задаётся той же двери: других дверей к строкам нет.
   */
  update(viewer: number, id: number, patch: NotePatch): NoteOut {
    const saved = this.#repo.update(viewer, id, patch);
    if (saved !== null) return saved;
    if (this.#repo.byId(viewer, id) === null) fail("NOT_FOUND", `заметка ${id}`);
    fail("NOT_YOUR_NOTE", `заметка ${id}`);
  }

  publish(viewer: number, id: number): NoteOut {
    return this.update(viewer, id, { status: "published" });
  }
}

const service = new NotesService(new NotesRepo(new Db()));

const попытка = (label: string, действие: () => NoteOut): void => {
  try {
    const out = действие();
    console.log(`${label}: ${out.title} (${out.status})`);
  } catch (error) {
    console.log(`${label}: отказ ${error instanceof DomainError ? error.code : String(error)}`);
  }
};

попытка("Аня правит свой черновик   ", () => service.update(1, 2, { title: "План отпуска" }));
попытка("Боб правит чужой черновик  ", () => service.update(2, 2, { title: "Моё" }));
попытка("Боб правит чужую публичную ", () => service.update(2, 1, { title: "Моё" }));
попытка("Боб правит несуществующую  ", () => service.update(2, 99, { title: "Моё" }));
попытка("Боб читает чужой черновик  ", () => service.byId(2, 2));
попытка("Аня публикует свой черновик", () => service.publish(1, 2));
попытка("Боб читает её же теперь    ", () => service.byId(2, 2));

type Status = "draft" | "published";
type NoteOut = { id: number; title: string; body: string; status: Status; author: string };
type NotePatch = { title?: string; body?: string; status?: Status };
type Issue = { path: string; message: string };
type Result<T> = { ok: true; value: T } | { ok: false; issues: Issue[] };
interface Schema<T> {
  check(value: unknown, path: string): Result<T>;
}
type Infer<S> = S extends Schema<infer T> ? T : never;
type Class = new (...args: never[]) => object;
type Proc = { input: Schema<unknown>; run: (input: never) => unknown };
type Res = { status: number; body: string };

// Всё, что читатель уже написал, — на подложке: контейнер и модули главы 5,
// перевод отказа в ответ из главы 6, схемы и процедуры, таблица главы 9
// и проект из разделов выше
declare const text: Schema<string>;
declare const int: Schema<number>;
declare function object<F extends Record<string, Schema<unknown>>>(fields: F): Schema<{ [K in keyof F]: Infer<F[K]> }>;
declare function procedure<S extends Schema<unknown>, O>(input: S, run: (input: Infer<S>) => O): { input: S; run: (input: Infer<S>) => O };
declare function call(router: object, path: string, raw: unknown): unknown;
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>(from: Class, token: new (...args: never[]) => T): T;
}
declare class HttpError extends Error {
  constructor(status: number, message: string);
}
declare function toResponse(error: unknown): Res;
declare class Db {}
declare class NotesRepo {
  constructor(db: Db);
  page(viewer: number, n: number): NoteOut[];
}
declare class NotesService {
  constructor(repo: NotesRepo);
  page(viewer: number, n: number): NoteOut[];
  byId(viewer: number, id: number): NoteOut;
  create(authorId: number, input: { title: string; body: string }): NoteOut;
  update(viewer: number, id: number, patch: NotePatch): NoteOut;
  publish(viewer: number, id: number): NoteOut;
}

// Подкласс здесь ровно затем, чтобы приписать классу список зависимостей:
// декоратор ставится там, где класс объявлен, а проект объявлен разделами выше
@Injectable()
class Tables extends Db {}

@Injectable({ deps: [Tables] })
class Repo extends NotesRepo {}

@Injectable({ deps: [Repo] })
class Notes extends NotesService {}

@Module({ providers: [Tables], exports: [Tables] })
class CommonModule {}

@Module({ imports: [CommonModule], providers: [Repo, Notes], exports: [Notes] })
class NotesModule {}

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

const container = new App();
const service = container.get(AppModule, Notes);

// Роутер собирается на каждый запрос: личность входит в него замыканием,
// поэтому в схему входа она не попадает и подделать её нечем
const routerFor = (viewer: number) => ({
  notes: {
    list: procedure(object({ page: int }), (input) => service.page(viewer, input.page)),
    byId: procedure(object({ id: int }), (input) => service.byId(viewer, input.id)),
    create: procedure(object({ title: text, body: text }), (input) => service.create(viewer, input)),
    publish: procedure(object({ id: int }), (input) => service.publish(viewer, input.id)),
  },
});

// Имена процедур читаются из самого роутера: второго списка имён нет
const names = (node: object, prefix = ""): string[] =>
  Object.entries(node).flatMap(([key, value]) =>
    "run" in (value as Proc) ? [`${prefix}${key}`] : names(value as object, `${prefix}${key}.`),
  );

// Единственное место, где отказ становится ответом
const answer = (viewer: number, name: string, raw: unknown): Res => {
  const router = routerFor(viewer);
  if (!names(router).includes(name)) return toResponse(new HttpError(404, name));
  try {
    return { status: 200, body: JSON.stringify(call(router, name, raw)) };
  } catch (error) {
    // схема отказывает TypeError — это неправ клиент, а не программа
    return toResponse(error instanceof TypeError ? new HttpError(400, error.message) : error);
  }
};

const кратко = (body: string): string => {
  const value: unknown = JSON.parse(body);
  return Array.isArray(value) ? (value as NoteOut[]).map((row) => row.title).join(" | ") : body;
};

// Границу модуля видно только просьбой: контейнер отвечает или отказывает
const изКорня = (token: Class): string => {
  try {
    container.get(AppModule, token);
    return "отдал";
  } catch (error) {
    return error instanceof Error ? error.message : String(error);
  }
};

console.log("процедуры:", names(routerFor(0)).join(", "));
console.log("корень просит сервис:", изКорня(Notes));
console.log("корень просит репозиторий:", изКорня(Repo));

const requests: [string, number, string, unknown][] = [
  ["гость, список         ", 0, "notes.list", { page: 0 }],
  ["Аня, список           ", 1, "notes.list", { page: 0 }],
  ["Боб, чужой черновик   ", 2, "notes.byId", { id: 2 }],
  ["Боб, чужая публичная  ", 2, "notes.publish", { id: 1 }],
  ["Аня, пустой заголовок ", 1, "notes.create", { title: "   ", body: "" }],
  ["Аня, создание         ", 1, "notes.create", { title: " Список покупок ", body: "молоко" }],
  ["Аня, публикация       ", 1, "notes.publish", { id: 6 }],
  ["гость, такой нет      ", 0, "notes.remove", { id: 1 }],
];
for (const [label, viewer, name, raw] of requests) {
  const res = answer(viewer, name, raw);
  console.log(`${label} ${res.status} ${кратко(res.body)}`);
}