如何处理从 dto 到具有字段 promise 的实体的 promise？

Question

I got a problem when mapping Dto to the entity where there is a column that has promises, when I mapped from dto to entity, in json there is __entity __... I want to get rid of this

I tried mapping 1 by 1, but this is irrelevant if the column is so many, I tried Object.assign successfully, but when in Return json there is still entity

this here are some code snippets

Class Entity

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

DTO

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

Function,

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;
  }

I tried the code snippet above, it worked, but too many mapped, and i try

Object.assign(resumePayload, resume);

but return in 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__": []
 }

i wan't remove ___education__ without to many mapped

Regards

Answer 1

I'm sure libraries already exist for this, but I think a simple Typescript function may look as follows:

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;
}

It's not efficient but it wouldn't need any external libraries which might be useful if you don't want dependencies.

And note, it's really not efficient , it doesn't try to resolve all of the promises in parallel and it awaits variables that aren't promises which is not ideal.

You also lose your typing, which could be solved by using templating:

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

But then you have to define an object U that is just the resolved version of T .

---

An example of using this function would look as follows:

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'));