Сделайте все поля в интерфейсе только для чтения вложенным способом

Question

Я знаю, что мы можем использовать Readonly, чтобы повторно объявить все поля T как только для чтения, как в: [ Typescript: расширение интерфейса и повторное указание существующих полей как только для чтения

А как насчет вложенных полей? Например:

interface School {
  teachers: Array<Teacher>;
  students: Array<Student>;
}

interface Teacher {
  teacherId: number;
  personInfo: PersonInfo;
}

interface Student {
  studentId: number;
  personInfo: PersonInfo;
}

interface PersonInfo {
  name: string;
  age: number
}

Как создать тип SchoolReadonly, в котором все вложенные поля доступны только для чтения.

Простой тестовый пример:

var s: SchoolReadonly = {
  teachers: [{teacherId: 1, personInfo: {name: "John", age: 40}}],
  students: [{studentId: 1, personInfo: {name: "Dan", age: 20}}]
}

s.teachers[0].personInfo.name = "John2"; //should produce readonly error
s.students[0].personInfo.age = 22; //should produce readonly error

В качестве ограничения я не хочу добавлять Readonly напрямую в интерфейсы School, Teacher, Student и PersonInfo.

Answer 1

Вы можете использовать дженерики и псевдонимы типов, это много кода, но это поможет:

interface School<T extends Teacher<PersonInfo>, S extends Student<PersonInfo>> {
    teachers: Array<T>;
    students: Array<S>;
}

type EditableSchool = School<EditableTeacher, EditableStudent>;
type ReadonlySchool = Readonly<School<ReadonlyTeacher, ReadonlyStudent>>;

interface Teacher<P extends PersonInfo> {
    teacherId: number;
    personInfo: P;
}

type EditableTeacher = Teacher<PersonInfo>;
type ReadonlyTeacher = Readonly<Teacher<Readonly<PersonInfo>>>;

interface Student<P extends PersonInfo> {
    studentId: number;
    personInfo: P;
}

type EditableStudent = Student<PersonInfo>;
type ReadonlyStudent = Readonly<Student<Readonly<PersonInfo>>>;

interface PersonInfo {
    name: string;
    age: number
}

var s: ReadonlySchool = {
  teachers: [{teacherId: 1, personInfo: {name: "John", age: 40}}],
  students: [{studentId: 1, personInfo: {name: "Dan", age: 20}}]
}

s.teachers = null;
s.teachers[0].personInfo.name = "John2"; // Cannot assign to 'name' because it is a constant or a read-only property
s.students[0].personInfo.age = 22; // Cannot assign to 'age' because it is a constant or a read-only property

( код на детской площадке)

---

редактировать

Если ты хочешь s.teachers[0] = nul потерпеть неудачу, то вам также нужно изменить Array в ReadonlyArray, так:

interface School<T extends Teacher<PersonInfo>, Ta extends ArrayLike<T>, S extends Student<PersonInfo>, Ts extends ArrayLike<S>> {
    teachers: Ta;
    students: Ts;
}

type EditableSchool = School<EditableTeacher, Array<EditableTeacher>, EditableStudent, Array<EditableStudent>>;
type ReadonlySchool = Readonly<School<ReadonlyTeacher, ReadonlyArray<ReadonlyTeacher>, ReadonlyStudent, ReadonlyArray<ReadonlyStudent>>>;

В остальном то же самое, но потом:

s.teachers = null; // Cannot assign to 'teachers' because it is a constant or a read-only property
s.teachers[0] = null; // Index signature in type 'ReadonlyArray<Readonly<Teacher<Readonly<PersonInfo>>>>' only permits reading

Правда, это не простое решение и очень многословное, но я не думаю, что существует простое общее решение, по крайней мере, на данный момент, для этой проблемы.
Рассматривать:

type ReadyonlyDeep<T> = {
    readonly [P in keyof T]: ReadyonlyDeep<T[P]>;
}

Это прекрасно работает, если у объекта есть только другие простые объекты:

interface A {
    b: B
}

interface B {
    str: string;
}

let a: ReadyonlyDeep<A>;
a.b.str = "fe"; // Cannot assign to 'str' because it is a constant or a read-only property

Но если вы введете массив:

interface B {
    str: string;
    moreB: B[];
}

Затем:

a.b.moreB = []; // Cannot assign to 'moreB' because it is a constant or a read-only property
a.b.moreB[0].str = "hey"; // this is fine though

Это, вероятно, не простая проблема, чтобы решить.