Роли и владение: когда чужая строка отвечает 404, а когда 403

// Каркас со стражами, таблица, криптография и страж authenticate — в подложке
type Class = new (...args: any[]) => object;
type Identity = { sub: string; role: string };
type Req = { method: string; target: string; headers?: Record<string, string>; body?: string; user?: Identity };
type Res = { status: number; body: string };
type Call = { params: Record<string, string>; query: URLSearchParams; body: string; user?: Identity };
type Ctx = { request: Req; params: Record<string, string>; query: URLSearchParams; controller: string; handler: string };
type Guard = (ctx: Ctx) => boolean | Promise<boolean>;
type Pipe = (call: Call, ctx: Ctx) => Call | Promise<Call>;
type Deco = (value: Class, context: ClassDecoratorContext) => void;
type MethodDeco = (handler: Function, context: ClassMethodDecoratorContext) => void;
type Note = { id: number; title: string; author: number; status: "published" | "draft" };
declare const SECRET: string;
declare const NOW: number;
declare const DAY: number;
declare const ada: { id: number };
declare const bob: { id: number };
declare const users: { insert(values: Record<string, unknown>): { id: number } };
declare const authenticate: Guard;
declare const whoAmI: Pipe;
declare const admin: Guard;
declare function signToken(secret: string, claims: object): Promise<string>;
declare class Table {
  insert(values: Omit<Note, "id">): Note;
  update(id: number, patch: Partial<Note>): Note | null;
  remove(id: number): boolean;
}
declare function Module(options: { controllers?: Class[] }): Deco;
declare function Controller(prefix: string, options?: { deps?: Class[] }): Deco;
declare function Post(path?: string): MethodDeco;
declare function Delete(path?: string): MethodDeco;
declare function UseGuards(...guards: Guard[]): Deco & MethodDeco;
declare function UsePipes(...pipes: Pipe[]): Deco & MethodDeco;
declare function createApp(root: Class): { inject(request: Req): Promise<Res> };
declare class HttpError extends Error {
  constructor(status: number, message: string);
  readonly status: number;
}

// Модератор — строка в той же таблице пользователей, что ada и bob: страж спросит её
const mod = users.insert({ email: "mod@example.com", role: "admin" });

const notes = new Table();
notes.insert({ title: "Хлеб и молоко", author: ada.id, status: "published" });
notes.insert({ title: "План побега", author: ada.id, status: "draft" });
notes.insert({ title: "Отчёт за март", author: bob.id, status: "published" });

@UseGuards(authenticate)
@UsePipes(whoAmI)
@Controller("/notes")
class NotesController {
  // новый заголовок — в теле, номер заметки — в адресе
  @Post("/:id/title")
  rename(call: Call) {
    const row = notes.update(Number(call.params.id), { title: call.body });
    if (row === null) throw new HttpError(404, "нет такой");
    return `заголовок ${row.id} теперь «${row.title}»`;
  }

  // удалять разрешено только роли admin
  @UseGuards(admin)
  @Delete("/:id")
  remove(call: Call) {
    return notes.remove(Number(call.params.id)) ? `удалена ${call.params.id}` : "нет такой";
  }
}

@Module({ controllers: [NotesController] })
class AppModule {}

const app = createApp(AppModule);

async function main() {
  const day = NOW + DAY;
  const bobToken = await signToken(SECRET, { sub: String(bob.id), role: "user", exp: day });
  const modToken = await signToken(SECRET, { sub: String(mod.id), role: "admin", exp: day });

  const tries: [string, string, string, string, string][] = [
    ["Боб правит свою", bobToken, "POST", "/notes/3/title", "Отчёт за март, дополнено"],
    ["Боб правит чужую опубликованную", bobToken, "POST", "/notes/1/title", "Хлеб, молоко и соль"],
    ["Боб правит чужой черновик", bobToken, "POST", "/notes/2/title", "План побега (отменён)"],
    ["Боб удаляет чужой черновик", bobToken, "DELETE", "/notes/2", ""],
    ["модератор удаляет чужой черновик", modToken, "DELETE", "/notes/2", ""],
  ];
  for (const [name, token, method, target, body] of tries) {
    const response = await app.inject({ method, target, body, headers: { authorization: `Bearer ${token}` } });
    console.log(`${name}: ${response.status} ${response.body}`);
  }
}

main();

// Таблица и HttpError — в подложке; здесь только сервис и перебор
type Note = { id: number; title: string; author: number; status: "published" | "draft" };
type Rule = () => never;
declare const ada: { id: number };
declare const bob: { id: number };
declare class Table {
  insert(values: Omit<Note, "id">): Note;
  remove(id: number): boolean;
  where(match: (row: Note) => boolean): Note[];
}
declare class HttpError extends Error {
  constructor(status: number, message: string);
  readonly status: number;
}

const notes = new Table();
notes.insert({ title: "Хлеб и молоко", author: ada.id, status: "published" });
notes.insert({ title: "План побега", author: ada.id, status: "draft" });
notes.insert({ title: "Отчёт за март", author: bob.id, status: "published" });
notes.insert({ title: "Черновик письма", author: ada.id, status: "draft" });
notes.insert({ title: "Идеи на лето", author: ada.id, status: "draft" });
notes.insert({ title: "Ремонт кухни", author: bob.id, status: "draft" });
// два номера освободились: заметки удалили, и новых с этими номерами уже не будет
notes.remove(4);
notes.remove(6);

// Правило про чужой черновик — единственная разница между двумя сервисами
const asForbidden: Rule = () => {
  throw new HttpError(403, "это не ваша заметка");
};
const asMissing: Rule = () => {
  throw new HttpError(404, "нет такой");
};

function byId(id: number, viewer: number, onForeignDraft: Rule): Note {
  const [row] = notes.where((item) => item.id === id);
  if (row === undefined) throw new HttpError(404, "нет такой");
  if (row.status === "draft" && row.author !== viewer) onForeignDraft();
  return row;
}

// Так перебирает тот, у кого есть свой честный токен и полчаса времени
function probe(onForeignDraft: Rule): { codes: string; exists: number; hidden: number } {
  const codes: string[] = [];
  let exists = 0;
  let hidden = 0;
  for (let id = 1; id <= 8; id += 1) {
    let status = 200;
    try {
      byId(id, bob.id, onForeignDraft);
    } catch (error) {
      status = (error as HttpError).status;
    }
    codes.push(`${id}:${status}`);
    if (status !== 404) exists += 1;
    if (status === 403) hidden += 1;
  }
  return { codes: codes.join(" "), exists, hidden };
}

for (const [name, rule] of [["403 на чужой черновик", asForbidden], ["404 на чужой черновик", asMissing]] as const) {
  const result = probe(rule);
  console.log(`${name}: ${result.codes}`);
  console.log(`  Боб узнал: заметок существует ${result.exists}, из них чужих скрытых ${result.hidden}`);
}

// Таблица и HttpError — в подложке; здесь сервис заметок целиком
type Note = { id: number; title: string; author: number; status: "published" | "draft" };
declare const ada: { id: number };
declare const bob: { id: number };
declare class Table {
  insert(values: Omit<Note, "id">): Note;
  update(id: number, patch: Partial<Note>): Note | null;
  remove(id: number): boolean;
  where(match: (row: Note) => boolean): Note[];
}
declare class HttpError extends Error {
  constructor(status: number, message: string);
  readonly status: number;
}

const notes = new Table();
notes.insert({ title: "Хлеб и молоко", author: ada.id, status: "published" });
notes.insert({ title: "План побега", author: ada.id, status: "draft" });
notes.insert({ title: "Отчёт за март", author: bob.id, status: "published" });
notes.insert({ title: "Ремонт кухни", author: bob.id, status: "draft" });

const notFound = () => new HttpError(404, "нет такой");
const notYours = () => new HttpError(403, "это не ваша заметка");

class NotesService {
  #row(id: number): Note | undefined {
    return notes.where((row) => row.id === id)[0];
  }

  // Чтение: опубликованное видно всем, черновик — только автору
  byId(id: number, viewer: number): Note {
    const row = this.#row(id);
    if (row === undefined) throw notFound();
    if (row.status === "draft" && row.author !== viewer) throw notFound();
    return row;
  }

  rename(viewer: number, id: number, title: string): Note {
    const row = this.#mustOwn(viewer, id);
    return notes.update(row.id, { title })!;
  }

  remove(viewer: number, id: number): string {
    const row = this.#mustOwn(viewer, id);
    notes.remove(row.id);
    return `удалена ${row.id}`;
  }

  // Одна проверка владения на все пишущие обработчики: два её списка
  // разошлись бы, а ответы обязаны совпадать до кода и до слова
  #mustOwn(viewer: number, id: number): Note {
    const row = this.#row(id);
    if (row === undefined) throw notFound();
    if (row.author !== viewer) throw row.status === "draft" ? notFound() : notYours();
    return row;
  }
}

const service = new NotesService();

// Один и тот же вызов через try: нужен только ответ, а не строка
function answer(call: () => unknown): string {
  try {
    call();
    return "200";
  } catch (error) {
    const http = error as HttpError;
    return `${http.status} ${http.message}`;
  }
}

const cases: [string, number][] = [
  ["своя опубликованная", 3],
  ["свой черновик", 4],
  ["чужая опубликованная", 1],
  ["чужой черновик", 2],
  ["номер, которого нет", 9],
];
for (const [name, id] of cases) {
  const read = answer(() => service.byId(id, bob.id));
  const write = answer(() => service.rename(bob.id, id, "новый заголовок"));
  const drop = answer(() => service.remove(bob.id, id));
  console.log(`${name} (${id}): чтение ${read}, правка ${write}, удаление ${drop}`);
}

// Таблица и HttpError — в подложке
type Note = { id: number; title: string; author: number; status: "published" | "draft" };
declare const ada: { id: number };
declare const bob: { id: number };
declare class Table {
  insert(values: Omit<Note, "id">): Note;
  update(id: number, patch: Partial<Note>): Note | null;
  where(match: (row: Note) => boolean): Note[];
}
declare class HttpError extends Error {
  constructor(status: number, message: string);
  readonly status: number;
}

const notes = new Table();
notes.insert({ title: "Хлеб и молоко", author: ada.id, status: "published" });
notes.insert({ title: "План побега", author: ada.id, status: "draft" });
notes.insert({ title: "Отчёт за март", author: bob.id, status: "published" });

// Одним запросом: владение уехало в условие правки — UPDATE … WHERE id = ? AND author = ?
function renameByOne(viewer: number, id: number, title: string): number {
  const found = notes.where((row) => row.id === id && row.author === viewer);
  for (const row of found) notes.update(row.id, { title });
  return found.length;
}

// Двумя: сначала прочитать строку, потом решить, что ответить
function renameByTwo(viewer: number, id: number, title: string): void {
  const row = notes.where((item) => item.id === id)[0];
  if (row === undefined) throw new HttpError(404, "нет такой");
  if (row.author !== viewer) {
    throw row.status === "draft" ? new HttpError(404, "нет такой") : new HttpError(403, "это не ваша заметка");
  }
  notes.update(row.id, { title });
}

function answer(call: () => unknown): string {
  try {
    call();
    return "200";
  } catch (error) {
    const http = error as HttpError;
    return `${http.status} ${http.message}`;
  }
}

const cases: [string, number][] = [
  ["своя опубликованная", 3],
  ["чужая опубликованная", 1],
  ["чужой черновик", 2],
  ["номер, которого нет", 9],
];
for (const [name, id] of cases) {
  const changed = renameByOne(bob.id, id, "новый заголовок");
  // ответить нечем, кроме числа изменённых строк: строку никто не читал
  const one = changed === 0 ? "404 нет такой" : "200";
  const two = answer(() => renameByTwo(bob.id, id, "новый заголовок"));
  console.log(`${name} (${id}): одним запросом изменено ${changed} → ${one}; двумя → ${two}`);
}

// apps/api/src/notes/notes.service.ts, выдержка

  async byId(id: string, viewerId: string | null): Promise<NoteDto> {
    const row = await this.repo.findWithAuthor(id);
    if (!row) throw domainError('NOT_FOUND');
    // чужой черновик отвечает так же, как несуществующий: FORBIDDEN подтвердил бы,
    // что заметка с таким id есть, и по перебору id читалась бы карта черновиков
    if (row.status === 'draft' && row.authorId !== viewerId) throw domainError('NOT_FOUND');
    return mapNote(row);
  }

  async remove(authorId: string, id: string): Promise<{ ok: true }> {
    await this.mustOwn(authorId, id);
    await this.repo.remove(id);
    return { ok: true };
  }

  /**
   * Проверка владения. Ответ разный по той же причине, что и в byId: про чужой
   * черновик мы не подтверждаем даже факт существования, а про чужую
   * опубликованную заметку честно говорим, что она не ваша.
   */
  private async mustOwn(authorId: string, noteId: string): Promise<NoteRow> {
    const note = await this.repo.findById(noteId);
    if (!note) throw domainError('NOT_FOUND');
    if (note.authorId !== authorId) {
      throw domainError(note.status === 'draft' ? 'NOT_FOUND' : 'NOT_YOUR_RESOURCE');
    }
    return note;
  }

// apps/api/src/configs/trpc/middlewares/role.middlewares.ts, выдержка

/**
 * Только администратор.
 *
 * В стартере админских процедур нет: заметки принадлежат авторам, и модерация
 * ломала бы правило «править и удалять может только автор». Middleware перенесён
 * как готовый образец разграничения по ролям — вешается декоратором
 * `@UseMiddlewares(AdminOnlyMiddleware)` на процедуру или на весь роутер.
 * Его поведение закреплено тестом role.middlewares.spec.ts.
 */
@Injectable()
export class AdminOnlyMiddleware implements TRPCMiddleware {
  constructor(
    @Inject(DrizzleAsyncProvider) private readonly db: DrizzleDB,
    private readonly configService: ConfigService,
  ) {}

  async use(opts: MiddlewareOptions<IAppContext>) {
    const identity = await authenticate(this.db, this.configService, opts.ctx);
    if (identity.role !== 'admin') {
      throw new TRPCError({ code: 'FORBIDDEN', message: 'WRONG_ROLE' });
    }
    return opts.next({ ctx: identity });
  }
}