Add new sibling job in flow at runtime

As a worker, I’d like to be able to inject a new job into a flow at the same level as the current job (same parentId) I tried just creating a new job with the same parentId via JobsOptions.parent but the parent job still ran before the new child. Any advice on how to get my desired behavior?

[roggervalf]

hi @blankenshipz, I modified your first example a little bit, there were some data that were passed in an incorrect way:

it('should process children before the parent when jobs have been added to the flow at runtime', async () => {
    const name = 'child-job';
    const values = [
      { bar: 'something' },
      { baz: 'something' },
      { qux: 'something' },
    ];

    const parentQueueName = `parent-queue-${v4()}`;

    let childrenProcessor,
      parentProcessor,
      processedChildren = 0;

    const processingChildren = new Promise<void>(
      resolve =>
        (childrenProcessor = async (job: Job) => {
          processedChildren++;

          if(processedChildren == 1) {
            await queue.add(name, {  qux: 'something', idx: 2}, 
            {parent:{ id: job?.parent.id, queue: `bull:${parentQueueName}`}});
          }

          console.log("Processing:  " + job.data.idx);

          if(processedChildren == 3) {
            resolve();
          }
          return job.data.idx;
        }),
    );

    const processingParent = new Promise<void>((resolve, reject) => [
      (parentProcessor = async (job: Job) => {
        try {
          const { processed, nextProcessedCursor } = await job.getDependencies({
            processed: {},
          });

          expect(nextProcessedCursor).to.be.equal(0);
          expect(Object.keys(processed)).to.have.length(3);
          resolve();
        } catch (err) {
          console.error(err);
          reject(err);
        }
      }),
    ]);

    const parentWorker = new Worker(parentQueueName, parentProcessor, {
      connection,
    });
    const childrenWorker = new Worker(queueName, childrenProcessor, {
      connection,
    });
    await parentWorker.waitUntilReady();
    await childrenWorker.waitUntilReady();

    const flow = new FlowProducer({ connection });
    const tree = await flow.add({
      name: 'parent-job',
      queueName: parentQueueName,
      data: {},
      children: [
        { name, data: { idx: 0, foo: 'bar' }, queueName },
        { name, data: { idx: 1, foo: 'baz' }, queueName },
      ],
    });

    expect(tree).to.have.property('job');
    expect(tree).to.have.property('children');

    const { job } = tree;
    const parentState = await job.getState();

    expect(parentState).to.be.eql('waiting-children');

    await processingChildren;
    await childrenWorker.close();
    const dependencyCount = await job.getDependenciesCount();

    expect(dependencyCount.processed).to.eql(3);

    await processingParent;
    await parentWorker.close();

    await flow.close();
    await removeAllQueueData(new IORedis(), parentQueueName);
  });

this one is working

[roggervalf]

As we have a pattern to handle step jobs, this issue could be closed I think