Typescript Pagination system

models.tsx

// abstract classes
export abstract class BaseModelData {
    id: number;
}

export abstract class BaseModel {
    public abstract toJson<U extends BaseModelData>(): U;
}
// end abstract classes


// interfaces 
export interface TaskData extends BaseModelData {
    id: number;
    designation: string;
    reminder_date: string;
    status: string;
}

export interface PaginationData {
    page_number: number;
    per_page: number;
    total_items: number;
    total_pages: number;
    data: any[];
}
// end interfaces


    
// models
export class Pagination<T extends BaseModel> {
    page_number: number;
    per_page: number;
    total_items: number;
    total_pages: number;
    data: T[];

    constructor({ page_number, per_page, total_items, total_pages, data }: PaginationData) {
        this.page_number = page_number;
        this.per_page = per_page;
        this.total_items = total_items;
        this.total_pages = total_pages;
        this.data = data;
    }

    public static toModel<T extends BaseModel>(json: PaginationData): Pagination<T> {
        return new Pagination<T>(json);
    }

    public static empty<T extends BaseModel>(): Pagination<T> {
        return new Pagination<T>({
            page_number: 0,
            per_page: 0,
            total_items: 0,
            total_pages: 0,
            data: []
        });
    }

    public toJson(): PaginationData {
        return {
            page_number: this.page_number,
            per_page: this.per_page,
            total_items: this.total_items,
            total_pages: this.total_pages,
            data: this.data.map((instance) => instance.toJson())
        };
    }
}
// end models
    

// example model 
export class UserData extends BaseModelData {
    id: number;
    name: string;
    email: string;
}
    
export class ProjectData extends BaseModelData {
    id: number;
    name: string;
    date: string;
    responsible: UserData;
    clients: UserData[];
}


export class User extends BaseModel {
    id: number;
    name: string;
    email: string;

    constructor({id, name, email}: UserData) {
        super();
        this.id = id;
        this.name = name;
        this.email = email;
    }

    public toJson<UserData>(): UserData {
        return {
            id: this.id,
            name: this.name,
            email: this.email,
        } as UserData;
    }

    public static toJsonArray<UserData>(data: User[]): UserData[] {
        return data.map((user: User) => user.toJson());
    }

    public static toModel(json: UserData): User{
        return new User(json);
    }

    public static toModelArray(json: UserData[]): User[] {
        return json.map((userData: UserData) => User.toModel(userData));
    }

    public static toPaginatedModel(json: PaginationData): Pagination<User> {
        return new Pagination<User>({
            page_number: json.page_number,
            per_page: json.per_page,
            total_items: json.total_items,
            total_pages: json.total_pages,
            data: User.toModelArray(json.data)
        });
    }
}

export class Project extends BaseModel {
    id: number | undefined;
    name: string;
    date: string;
    responsible: User;
    clients: User[];

    constructor({id, name, date, responsible, clients}: ProjectData) {
        super();
        this.id = id;
        this.name = name;
        this.date = date;
        this.responsible = User.toModel(responsible);
        this.clients = User.toModelArray(clients);
    }

    public toJson<ProjectData>(): ProjectData {
        return {
            id: this.id,
            name: this.name,
            date: this.date,
            responsible: this.responsible.toJson(),
            clients: User.toJsonArray(this.clients),
        } as ProjectData;
    }

    public static toJsonArray<ProjectData>(data: Project[]): ProjectData[] {
        return data.map((project: Project) => project.toJson());
    }

    public static toModel(json: ProjectData): Project{
        return new Project(json);
    }

    public static toModelArray(json: ProjectData[]): Project[] {
        return json.map((projectData: ProjectData) => Project.toModel(projectData));
    }

    public static toPaginatedModel(json: PaginationData): Pagination<Project> {
        return new Pagination<Project>({
            page_number: json.page_number,
            per_page: json.per_page,
            total_items: json.total_items,
            total_pages: json.total_pages,
            data: Project.toModelArray(json.data)
        });
    }
}

// end example model 

TODO : Améliorer le toPaginatedModel() pour gérer que le data dans le model