Собираем валидатор границы: проверка в рантайме и вывод типа

interface Note {
  title: string;
  status: string;
}

function fail(path: string, message: string): never {
  throw new TypeError(`${path}: ${message}`);
}

// Разбор на входе: unknown внутрь, Note наружу
function parseNote(raw: unknown, path: string): Note {
  if (typeof raw !== "object" || raw === null) fail(path, "ожидался объект");
  const source = raw as Record<string, unknown>;
  if (typeof source.title !== "string") fail(`${path}.title`, "ожидалась строка");
  const title = source.title.trim();
  if (title === "") fail(`${path}.title`, "не может быть пустым");
  const status = source.status;
  if (status !== "draft" && status !== "published") {
    fail(`${path}.status`, "ожидалось одно из: draft, published");
  }
  return { title, status };
}

function badge(note: Note): string {
  if (note.status === "draft") return "черновик";
  if (note.status === "published") return "опубликовано";
  return `неизвестный статус: ${note.status}`;
}

const fromClient: unknown = JSON.parse('{"title":"  Первая заметка  ","status":"draft","admin":true}');
console.log(badge(parseNote(fromClient, "body")));

const broken: unknown = JSON.parse('{"title":"   ","status":"archived"}');
try {
  parseNote(broken, "body");
} catch (error) {
  console.log(error instanceof Error ? error.message : error);
}

// эту заметку разбор бы не пропустил, а компилятор её принимает
console.log(badge({ title: "чужая", status: "archived" }));

type Issue = { path: string; message: string };
type Result<T> = { ok: true; value: T } | { ok: false; issues: Issue[] };

// Схема — не код проверки, а значение: внутри check, а в типе видно, что выйдет наружу
interface Schema<T> {
  check(value: unknown, path: string): Result<T>;
}

const issue = (path: string, message: string): Result<never> => ({ ok: false, issues: [{ path, message }] });

const text: Schema<string> = {
  check(value, path) {
    if (typeof value !== "string") return issue(path, "ожидалась строка");
    const trimmed = value.trim();
    return trimmed === "" ? issue(path, "не может быть пустым") : { ok: true, value: trimmed };
  },
};

const int: Schema<number> = {
  check(value, path) {
    return typeof value === "number" && Number.isInteger(value)
      ? { ok: true, value }
      : issue(path, "ожидалось целое число");
  },
};

console.log(text.check("  Первая заметка  ", "body.title"));
console.log(text.check("   ", "body.title"));
console.log(int.check(7, "body.count"));
console.log(int.check(7.5, "body.count"));

// Схема ездит как любое другое значение, а T читается из аргумента
function parse<T>(schema: Schema<T>, value: unknown, path: string): T {
  const result = schema.check(value, path);
  if (!result.ok) throw new TypeError(result.issues.map((item) => `${item.path}: ${item.message}`).join("; "));
  return result.value;
}

const count = parse(int, 7, "body.count");
console.log("округлили:", count.toFixed(2));

// @ts-expect-error компилятор узнал из схемы, что здесь число
const wrong: string = parse(int, 7, "body.count");

// Ядро валидатора — в подложке, здесь только его типы
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>;
}
declare const issue: (path: string, message: string) => Result<never>;
declare const text: Schema<string>;

// Что схема выдаёт наружу — записано в ней самой, надо только прочитать
type Infer<S> = S extends Schema<infer T> ? T : never;

const isOneOf = <T extends string>(allowed: readonly T[], value: unknown): value is T =>
  typeof value === "string" && allowed.some((item) => item === value);

// T выводится из аргументов и остаётся объединением литералов
function oneOf<T extends string>(...allowed: T[]): Schema<T> {
  return {
    check: (value, path) =>
      isOneOf(allowed, value)
        ? { ok: true, value }
        : issue(path, `ожидалось одно из: ${allowed.join(", ")}`),
  };
}

type Fields = Record<string, Schema<unknown>>;

// Поля разбираются все: отказ одного не мешает узнать про остальные
function object<F extends Fields>(fields: F): Schema<{ [K in keyof F]: Infer<F[K]> }> {
  return {
    check(value, path) {
      if (typeof value !== "object" || value === null) return issue(path, "ожидался объект");
      const source = value as Record<string, unknown>;
      const issues: Issue[] = [];
      const parsed: Record<string, unknown> = {};
      for (const key of Object.keys(fields)) {
        const result = fields[key].check(source[key], `${path}.${key}`);
        if (result.ok) parsed[key] = result.value;
        else issues.push(...result.issues);
      }
      // наружу едет новый объект: лишних полей исходника в нём нет
      return issues.length > 0
        ? { ok: false, issues }
        : { ok: true, value: parsed as { [K in keyof F]: Infer<F[K]> } };
    },
  };
}

const CreateNote = object({
  title: text,
  status: oneOf("draft", "published"),
});
type CreateNote = Infer<typeof CreateNote>;

console.log(CreateNote.check({ title: "  Первая заметка  ", status: "draft", admin: true }, "body"));
console.log(CreateNote.check({ title: "   ", status: "archived" }, "body"));

const draft: CreateNote = { title: "черновик", status: "draft" };
console.log("статус из типа:", draft.status);

// @ts-expect-error в схеме два статуса, и тип знает о них вместе с ней
const archived: CreateNote = { title: "старое", status: "archived" };
console.log("а схема в рантайме отвечает:", CreateNote.check(archived, "body").ok);

// Каркас главы и валидатор — в подложке, здесь их типы и новое
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;
declare const text: Schema<string>;
declare function oneOf<T extends string>(...allowed: T[]): Schema<T>;
declare function object<F extends Record<string, Schema<unknown>>>(fields: F): Schema<{ [K in keyof F]: Infer<F[K]> }>;

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<B = string> = { params: Record<string, string>; query: URLSearchParams; body: B };
type Ctx = { request: Req; params: Record<string, string>; query: URLSearchParams; controller: string; handler: string };
type Pipe<In, Out> = (call: Call<In>, ctx: Ctx) => Call<Out> | Promise<Call<Out>>;
type Deco = (value: Class, context: ClassDecoratorContext) => void;
type MethodDeco = (handler: Function, context: ClassMethodDecoratorContext) => void;
declare function Module(options: { providers?: Class[]; controllers?: Class[] }): Deco;
declare function Controller(prefix: string, options?: { deps?: Class[] }): Deco;
declare function Post(path?: string): MethodDeco;
// any здесь не лень: каркас не связывает выход трубы с параметром обработчика
declare function UsePipes(...pipes: Pipe<any, any>[]): 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;
}

// Одна труба на все маршруты: разные у них только схемы
function validated<T>(schema: Schema<T>): Pipe<string, T> {
  return (call) => {
    let raw: unknown;
    try {
      raw = JSON.parse(call.body);
    } catch {
      throw new HttpError(400, "body: ожидался JSON");
    }
    const result = schema.check(raw, "body");
    if (!result.ok) {
      throw new HttpError(400, result.issues.map((item) => `${item.path}: ${item.message}`).join("; "));
    }
    return { ...call, body: result.value };
  };
}

const CreateNote = object({ title: text, status: oneOf("draft", "published") });
type CreateNote = Infer<typeof CreateNote>;

@Controller("/notes")
class NotesController {
  @UsePipes(validated(CreateNote))
  @Post()
  create(call: Call<CreateNote>) {
    return `создана «${call.body.title}», статус ${call.body.status}`;
  }
}

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

const app = createApp(AppModule);

async function main() {
  const bodies = [
    '{"title":"  Первая заметка  ","status":"draft","admin":true}',
    '{"title":"   ","status":"archived"}',
    "тело без единой фигурной скобки",
  ];
  for (const body of bodies) {
    const response = await app.inject({ method: "POST", target: "/notes", body });
    console.log(`${response.status} ${response.body}`);
  }
}

main();

// Валидатор — в подложке, здесь его типы и договор
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;
declare const text: Schema<string>;
declare function oneOf<T extends string>(...allowed: T[]): Schema<T>;
declare function object<F extends Record<string, Schema<unknown>>>(fields: F): Schema<{ [K in keyof F]: Infer<F[K]> }>;

// Standard Schema v1 в сокращении — так договор объявляет @standard-schema/spec
type PathSegment = PropertyKey | { readonly key: PropertyKey };
type StandardIssue = { readonly message: string; readonly path?: readonly PathSegment[] };
type StandardResult<T> =
  | { readonly value: T; readonly issues?: undefined }
  | { readonly issues: readonly StandardIssue[] };
interface StandardSchemaV1<Output> {
  readonly "~standard": {
    readonly version: 1;
    readonly vendor: string;
    readonly validate: (value: unknown) => StandardResult<Output> | Promise<StandardResult<Output>>;
    readonly types?: { readonly output: Output };
  };
}

// Переходник: наша схема начинает говорить на общем языке, не меняясь внутри
function standard<T>(vendor: string, schema: Schema<T>): Schema<T> & StandardSchemaV1<T> {
  return {
    ...schema,
    "~standard": {
      version: 1,
      vendor,
      validate: (value) => {
        const result = schema.check(value, "");
        return result.ok
          ? { value: result.value }
          : {
              issues: result.issues.map((item) => ({
                message: item.message,
                // путь договора — массив ключей от корня схемы, а не одна строка
                path: item.path.split(".").filter(Boolean),
              })),
            };
      },
    },
  };
}

// Потребитель знает только договор — ни строчки о нашей библиотеке
async function parseBody<T>(schema: StandardSchemaV1<T>, raw: unknown): Promise<T> {
  const result = await schema["~standard"].validate(raw);
  if (result.issues) {
    const lines = result.issues.map((item) => {
      const path = (item.path ?? [])
        .map((segment) => (typeof segment === "object" ? segment.key : segment))
        .join(".");
      return `${path || "(корень)"}: ${item.message}`;
    });
    throw new TypeError(lines.join("; "));
  }
  return result.value;
}

const CreateNote = standard("свой валидатор", object({ title: text, status: oneOf("draft", "published") }));

async function main() {
  console.log("вендор:", CreateNote["~standard"].vendor);
  const note = await parseBody(CreateNote, { title: "  Первая заметка  ", status: "draft" });
  console.log("разобрано:", note.title.toUpperCase(), note.status);
  try {
    await parseBody(CreateNote, { title: "   ", status: "archived" });
  } catch (error) {
    console.log(error instanceof Error ? error.message : error);
  }
}

main();