Типобезопасные DTO и проверка во время выполнения

interface UserEntity {
  id: UserId;
  createdAt: Date;
  passwordHash: string;
}

interface UserDto {
  id: string;
  createdAt: string;
}

type UserDto = Pick<UserEntity, "id" | "createdAt">;

type UserResponse = { createdAt: Date };
const data = await fetch("/user").then(r => r.json()) as UserResponse;

const raw = await response.json();

function isObject(value: unknown): value is object {
  return typeof value === "object";
}

if (typeof value === "object" && value !== null && "id" in value) {
  // value.id
}

type ParseResult<T> =
  | { success: true; data: T }
  | { success: false; issues: readonly Issue[] };

const UserSchema = schema.object({ id: schema.string() });
type UserDto = Infer<typeof UserSchema>;

const parsed = UserSchema.parse(raw); // unknown keys are stripped

type InputError = {
  path: readonly (string | number)[];
  code: "required" | "invalid_type" | "invalid_format";
  message: string;
};

try {
  return schema.parse(raw);
} catch (error) {
  // ...
}

issues.map(issue => ({
  path: issue.path,
  code: mapCode(issue.code),
  message: localize(issue)
}));

declare const UserSchema: { parse(value: unknown): UserDto };
declare const raw: unknown;
const user = UserSchema.parse(raw);

type UserResponse = { id: string; displayName: string; createdAt: string };

type UserDto = Infer<typeof UserSchema>;

export interface UserResponse {
  id: string;
  displayName: string;
  createdAt: string;
}

interface UserEntity {
  id: string; displayName: string; createdAt: Date;
  passwordHash: string; ormMetadata: object;
}
type UserResponse = Pick<UserEntity, keyof UserEntity>;

type CreateUserResult =
 | { ok: true; user: UserResponse }
 | { ok: false; kind: "validation_error"; issues: readonly ValidationIssue[] }
 | { ok: false; kind: "conflict" };