Doubt about flush events

[jeroni]

I'm trying to set an entity as deleted when it's being deleted for the first time. Looking at the docs I can see an example that changes an update for delete in the onFlush method.
The code below changes the type from delete to update but the payload is empty and so nothing is updated:

(async() => {
    /**
     * create table person (
     *    id bigserial primary key,
     *    name text not null,
     *    deleted boolean not null default false
     * );
     */
    @Entity()
    class Person {
        @PrimaryKey()
        id?: number;

        @Property()
        name!: string;

        @Property()
        deleted!: boolean;
    }

    class MySubscriber implements EventSubscriber<Person> {
        onFlush(args: FlushEventArgs) {
            const changeSets: ChangeSet<Partial<Person>>[] = args.uow.getChangeSets().filter(cs =>
                cs.entity instanceof Person &&
                cs.type === ChangeSetType.DELETE
            );
            for (const cs of changeSets) {
                if (!cs.entity.deleted) {
                    cs.entity.deleted = true;
                    // Not working either with this: args.uow.recomputeSingleChangeSet(cs.entity);
                    args.uow.computeChangeSet(cs.entity, ChangeSetType.UPDATE);
                }
            }
        }

        afterFlush(args: FlushEventArgs): void | Promise<void> {
            console.log(args.uow.getChangeSets().find(cs => cs.type === ChangeSetType.UPDATE));
            /*
              ChangeSet<Person> {
                entity: Person { id: '7', name: 'Adrian Smith', deleted: true },
                type: 'update',
                payload: {},
                name: 'Person',
                rootName: 'Person',
                collection: 'person',
                schema: undefined,
                primaryKey: '7',
                persisted: true
             }
          */
        }
    }

    const orm = await MikroORM.init({
        entities: [Person],
        subscribers: [new MySubscriber()],
        dbName: 'mikro-orm-test',
        type: 'postgresql',
        host: 'localhost',
        password: '1234',
        port: 5432,
        user: 'postgres',
        debug: true,
        metadataProvider: ReflectMetadataProvider
    });

    const em1 = orm.em.fork();

    const person = new Person();
    person.name = 'Adrian Smith';
    person.deleted = false;
    await em1.persistAndFlush(person);

    const em2 = orm.em.fork();
    const personReloaded = await em2.findOne(Person, { deleted: false });
    await em2.removeAndFlush(personReloaded);


    await orm.close();
})()

So the only workaround is removing the onFlush method and use beforeFlush:

        beforeFlush(args: FlushEventArgs): void | Promise<void> {
            for (const entity of args.uow.getRemoveStack()) {
                if (entity instanceof Person && !entity.deleted) {
                    entity.deleted = true;
                    args.uow.getRemoveStack().delete(entity);
                    args.uow.getPersistStack().add(entity);
                }
            }
        }

Should the first approach do the job or is the second the only way to achieve it?

[B4nan]

I believe you should change the type of the existing change set and recompute that:

cs.type = ChangeSetType.UPDATE;
args.uow.recomputeSingleChangeSet(cs.entity);

[jeroni]

this isn't working, either:

        onFlush(args: FlushEventArgs) {
            const changeSets: ChangeSet<Partial<Person>>[] = args.uow.getChangeSets().filter(cs =>
                cs.entity instanceof Person &&
                cs.type === ChangeSetType.DELETE
            );
            for (const cs of changeSets) {
                if (!cs.entity.deleted) {
                    cs.entity.deleted = true;
                    cs.type = ChangeSetType.UPDATE;
                    args.uow.recomputeSingleChangeSet(cs.entity);
                    // args.uow.computeChangeSet(cs.entity, ChangeSetType.UPDATE);
                }
            }
        }

I tried too with computeChangeSet uncommented:

ChangeSet<Person> {
  entity: Person { id: '8', name: 'Adrian Smith', deleted: true },
  type: 'update',
  payload: {},
  name: 'Person',
  rootName: 'Person',
  collection: 'person',
  schema: undefined,
  primaryKey: '8',
  persisted: true
}

[B4nan]

you can always just alter the payload yourself.

but its weird, that method computes the changeset of the entity, and if deleted was true when the entity was loaded, the new changeset should contain it, that's the code does, its deadly simple.

https://github.com/mikro-orm/mikro-orm/blob/master/packages/core/src/unit-of-work/UnitOfWork.ts#L284-L291

[jeroni]

The loaded entity has deleted to false.
The purpose of the code is to set deleted = true the first time we try to delete it (not a second time), so we want to change the state of the object this first time.
Changing the payload surely works, without recomputing anything. Could be a UOW bug?

        onFlush(args: FlushEventArgs) {
            const changeSets: ChangeSet<Partial<Person>>[] = args.uow.getChangeSets().filter(cs =>
                cs.entity instanceof Person &&
                cs.type === ChangeSetType.DELETE
            );
            for (const cs of changeSets) {
                if (!cs.entity.deleted) {
                    // cs.entity.deleted = true;
                    cs.payload.deleted = true;
                    cs.type = ChangeSetType.UPDATE;
                    // args.uow.recomputeSingleChangeSet(cs.entity);
                    // args.uow.computeChangeSet(cs.entity, ChangeSetType.UPDATE);
                }
            }
        }

[B4nan]

Can you try to put some console logs to the place I highlighted to see whats going on?

[jeroni]

        onFlush(args: FlushEventArgs) {
            const changeSets: ChangeSet<Partial<Person>>[] = args.uow.getChangeSets().filter(cs =>
                cs.entity instanceof Person &&
                cs.type === ChangeSetType.DELETE
            );
            for (const cs of changeSets) {
                if (!cs.entity.deleted) {
                    cs.entity.deleted = true;
                    // cs.payload.deleted = true;
                    cs.type = ChangeSetType.UPDATE;
                    args.uow.recomputeSingleChangeSet(cs.entity);
                    // args.uow.computeChangeSet(cs.entity, ChangeSetType.UPDATE);
                }
            }
        }

recomputeSingleChangeSet(entity) {
        console.log('entity', entity);
        const changeSet = this.changeSets.get(entity);
        if (!changeSet) {
            return;
        }
        console.log('changeSet', changeSet);
        const cs = this.changeSetComputer.computeChangeSet(entity);
        console.log('cs', cs);
        /* istanbul ignore else */
        console.log('checkUniqueProps', !this.checkUniqueProps(changeSet));
        if (cs && !this.checkUniqueProps(changeSet)) {
            console.log('if');
            console.log('Assign', changeSet.payload, cs.payload);
            Object.assign(changeSet.payload, cs.payload);
            (0, entity_1.helper)(entity).__originalEntityData = this.comparator.prepareEntity(entity);
            console.log('after prepare entity', (0, entity_1.helper()(entity).__originalEntityData));
            (0, entity_1.helper)(entity).__touched = false;
        }
    }

Let me know if you want me to add more logs:

entity Person { id: '11', name: 'Adrian Smith', deleted: true }
changeSet ChangeSet<Person> {
  entity: Person { id: '11', name: 'Adrian Smith', deleted: true },
  type: 'update',
  payload: {},
  name: 'Person',
  rootName: 'Person',
  collection: 'person',
  schema: undefined
}
cs ChangeSet<Person> {
  entity: Person { id: '11', name: 'Adrian Smith', deleted: true },
  type: 'update',
  payload: { deleted: true },
  name: 'Person',
  rootName: 'Person',
  collection: 'person',
  schema: undefined,
  originalEntity: { id: '11', name: 'Adrian Smith', deleted: false }
}
checkUniqueProps false

Didn't enter into the if condition...

[jeroni]

By commenting out some code it works

    recomputeSingleChangeSet(entity) {
        console.log('entity', entity);
        const changeSet = this.changeSets.get(entity);
        if (!changeSet) {
            return;
        }
        console.log('changeSet', changeSet);
        const cs = this.changeSetComputer.computeChangeSet(entity);
        console.log('cs', cs);
        /* istanbul ignore else */
        console.log('checkUniqueProps', !this.checkUniqueProps(changeSet));
        if (cs /*&& !this.checkUniqueProps(changeSet)*/) {
            console.log('if');
            console.log('Assign', changeSet.payload, cs.payload);
            Object.assign(changeSet.payload, cs.payload);
            /*
            (0, entity_1.helper)(entity).__originalEntityData = this.comparator.prepareEntity(entity);
            console.log('after prepare entity', (0, entity_1.helper()(entity).__originalEntityData));
            (0, entity_1.helper)(entity).__touched = false;
             */
        }
    }

[B4nan]

I see, thanks. I think we either shouldn't have the checkUniqueProps there or it should be getting the new changeset in the parameter.

[B4nan]

d03afad?w=1

[jeroni]

[B4nan]

that comes from the console log, you have the helper() call wrong, without any arguments

[jeroni]

true, sorry. It's working now... thanks!