Блог

У меня возникла проблема при сопоставлении Dto с объектом, где есть столбец с обещаниями, когда я сопоставил dto с объектом, в json есть __entity __ … Я хочу избавиться от этого

Я попытался сопоставить 1 на 1, но это не имеет значения, если столбцов так много, я успешно попробовал Object.assign, но когда в Return json все еще остается объект

вот несколько фрагментов кода

Объект класса

 experiences: Promise<Experience[]>;
portfolios: Promise<Portfolio[]>;
 

DTO

 experiences?: ExperiencePayload[];
portfolios?: PortfolioPayload[];
 

Функция,

 public async getResumeByTalent(id: string): Promise<ResumePayload> {
    const resume: Resume = await this.resumeRepository.findOne({ relations: ['experiences', 'addresses', 'languages', 'educations', 'portfolios'], where: {talentId: id}});
    if (!resume) throw new BadRequestException(`Resume with Talent Id ${id} not found`);
    const {languages, educations, experiences, addresses, portfolios} =  resume;
    const resumePayload: ResumePayload = new ResumePayload();

    resumePayload.citizen = resume.citizen;
    resumePayload.citizenCard = resume.citizenCard;
    resumePayload.currentSalary = resume.currentSalary;
    resumePayload.expectedSalary = resume.expectedSalary;
    resumePayload.facebookProfile = resume.facebookProfile;
    resumePayload.githubProfile = resume.githubProfile;
    resumePayload.hobbies = resume.hobbies;
    resumePayload.job = resume.job;
    resumePayload.objective = resume.objective;
    resumePayload.skill = resume.skill;
    resumePayload.languages = await languages;
    resumePayload.educations = await educations;
    resumePayload.experiences = await experiences;
    resumePayload.addresses = await addresses;
    resumePayload.portfolios = await portfolios;
    return resumePayload;
  }
 

Я попробовал приведенный выше фрагмент кода, он сработал, но слишком много отображено, и я пытаюсь

 Object.assign(resumePayload, resume);
 

но возврат в json

 {
        "id": "asasasa",
        "talentId": "a6cb25db-21be-4303-b63e-c3dcbcd7b2a2",
        "citizen": "99999292",
        "citizenCard": "KTP",
        "skill": null,
        "expectedSalary": 100000,
        "currentSalary": 100000,
        "objective": "JASJASJAJS",
        "hobbies": "JJJJJ",
        "linkedinProfile": null,
        "githubProfile": null,
        "facebookProfile": null,
        "job": null,
        "createdAt": "2021-01-14T17:10:09.628Z",
        "createdBy": "system",
        "updatedAt": "2021-01-14T17:10:09.628Z",
        "updatedBy": null,
        "deletedAt": null,
        "deletedBy": null,
        "__experiences__": [],
        "__addresses__": [],
        "__languages__": [],
        "__educations__": [],
        "__portfolios__": []
 }
 

я не хочу удалять ___education__ , не сопоставляя со многими

С уважением

Я уверен, что для этого уже существуют библиотеки, но я думаю, что простая функция Typescript может выглядеть следующим образом:

 async function recursiveAwait(obj: any): Promise<any> {
    if (Array.isArray(obj)) {
        return (await Promise.all(obj.map(o => recursiveAwait(o))));
    }
    if (typeof obj === 'object') {
        for (const key in obj) {
            obj[key] = await recursiveAwait(obj[key]);
        }
        return obj;
    }
    return await obj;
}
 

Это неэффективно, но для этого не нужны какие-либо внешние библиотеки, которые могут быть полезны, если вам не нужны зависимости.

И обратите внимание, что это действительно неэффективно, оно не пытается разрешить все обещания параллельно и ожидает переменные, которые не являются обещаниями, что не идеально.

Вы также теряете ввод текста, что можно решить с помощью шаблонов:

 sync function recursiveAwait<T, U>(obj: T): Promise<U>;
 

Но тогда вам нужно определить объект U , который является только разрешенной версией T .

Пример использования этой функции будет выглядеть следующим образом:

 async function run() {
    let myPromises = {
        arrayOfThem: [
            new Promise(resolve => setTimeout(() => resolve(1), 1000)),
            new Promise(resolve => setTimeout(() => resolve(2), 2000)),
        ],
        oneOfThem: new Promise(resolve => setTimeout(() => resolve(3), 1500)),
        objectOfThem: {
            a: new Promise(resolve => setTimeout(() => resolve(4), 1000)),
            b: new Promise(resolve => setTimeout(() => resolve(5), 2000)),
        },
        somethingElse: {
            a: 'a',
            b: ['b', 'c']
        },
        str: 'string'
    }
    console.log(myPromises);
    myPromises = await recursiveAwait(myPromises);
    console.log(myPromises);
}

run().then(() => console.log('done'));