Transactions support

[mogadanez]

Readme says that adapter supports transactions. but not found any other mentions even in sources.
Is it any guides how to use it?

[mogadanez]

Some notes:

1. patch method

https://github.com/feathersjs-ecosystem/feathers-sequelize/blob/master/lib/index.js#L180
https://github.com/feathersjs-ecosystem/feathers-sequelize/blob/master/lib/index.js#L189

getModel method accept params but update method accept constructed options which use params.sequelize

So for right use transaction I need pass params like
{ sequelize: {transaction: t}, transaction: t}

2.events
events not have any knowledge about transactions, so emit message to client even if transaction is reverted.

[jumika]

It also worth mentioning, that update method doesn't even support transactions, or any sequelize parameters.

https://github.com/feathersjs-ecosystem/feathers-sequelize/blob/master/lib/index.js#L256
return instance.update(copy, {raw: false}).then(() => this._get(id, {sequelize: options}));
The only parameter passed to the update sequelize call is { raw: false }

[jumika]

For the events i created these hooks:

import { SKIP } from '@feathersjs/feathers';

function stackTransactionEvents(context) {
  const { params, service } = context;
  if(!params.sequelize || !params.sequelize.transaction) {
    return context;
  }

  if(!params.stackedEvents) params.stackedEvents = [];
  let event;
  switch(context.method) {
    case 'create':
    case 'update':
    case 'remove':
      event = context.method + 'd';
      break;
    case 'patch':
      event = 'patched';
      break;
  }
  if(event) {
    params.stackedEvents.push({
      service,
      event,
      data: context.dispatch ? context.dispatch : context.result,
      context
    });
  }
  return SKIP;
}

function unstackTransactionEvents(context) {
  const { params } = context;
  if(!params.sequelize || !params.sequelize.transaction || !params.stackedEvents) {
    return context;
  }
  params.stackedEvents.forEach(function(stackedEvent) {
    const {service, event, context} = stackedEvent;
    let { data } = stackedEvent;
    if(!Array.isArray(data)) {
      data = [data];
    }
    console.log('EMITTING ' + event);
    service.emit(event, data, context);
  });
  return context;
}

Use something like this as a patch before hook:
(Where content and route are associated models with respective services)

function patchTransaction(context) {
  const { data , app, service, params } = context;
  if(params.sequelize && params.sequelize.transaction) {
    return context;
  }
  // If the associated content ad route are sent with the data, then a transaction is created
  if(data.content && data.route) {
    const seq = app.get('sequelizeClient');
    return seq.transaction(function(t) {
      const paramsWithTransaction = {sequelize: {transaction: t}};
      return app.service('content').patch(data.contentId, data.content, paramsWithTransaction)
      .then(function() {
        return app.service('route').patch(data.routeId, data.route, paramsWithTransaction)
        .then(function() {
          return service.patch(data.id, data, paramsWithTransaction)
        });
      });
    }).then(async function() {
      context.result = await service.get(data.id);
      return SKIP;
    });
  }
  return context;
}

You have to use the stackTransactionEvents as the last after hook on your services which are called in your transaction. With returning SKIP the automatic event dispatching is disabled.

You have to use the unstackTransactionEvents as the last after hook on your service which creating the transaction.

Please keep inn mind, that I'm not a feathers expert. Maybe the code has some flaws, or design misconceptions.

It would be nice, if someone from the core team could take a look at it, and confirm this is a right approach.

@daffl What do you think?

[TimNZ]

Good catch on not wanting events to be emitted if the transaction is aborted.

I don't think the team will say this is a good approach as it's a hack.
Do you really want a SKIP in there as you have to remember your hook ordering?

I think it best if a hook.skipEvent prop is supported that the eventHook function, as a 'finally' hook called after 'after' hooks, checks whether to emit an event.

https://github.com/feathersjs/feathers/blob/master/lib/events.js#L6

const eventHook = exports.eventHook = function eventHook () {
  return function (hook) {
    if (hook.skipEvent) return; // <---- ADD THIS
    const { app, service } = hook;
    const eventName = app.eventMappings[hook.method];
    const isHookEvent = service._hookEvents && service._hookEvents.indexOf(eventName) !== -1;

    // If this event is not being sent yet and we are not in an error hook
    if (eventName && isHookEvent && hook.type !== 'error') {
      const results = Array.isArray(hook.result) ? hook.result : [ hook.result ];

      results.forEach(element => service.emit(eventName, element, hook));
    }
  };
};

I did a quick and dirty PR:
feathersjs/feathers#862

@daffl

[bernardobelchior]

Are there any guides on how to use transactions?
I'm trying but haven't been successful yet.

[TimNZ]

Feathers specific: Pass 'sequelize' as a param to your service calls, with a nested 'transaction'.

Read up on transactions in Sequelize for everything else to do with transaction lifetime.

app.get('sequelizeClient').transaction(transOptions, transaction => {
    return app.service('serviceName').create({data},{ sequelize: { transaction}  })
})

[bernardobelchior]

Thank you! Would you be interested in some documentation regarding transactions?

[TimNZ]

Just noticed the comments about update() not passing the transaction.

params.sequelize is not consistently passed to all sequelize calls, I'll do a PR.

[tunaung22]

My intention is to make multiple service call on before create hook.
When I tried inside a service's before create hook,
i got "TypeError: Converting circular structure to JSON" error.
What cause the problem ? Is there something wrong ?

myService.hooks.js:

  function (context) {
    ...
    app.get('sequelizeClient').transaction(transOptions, transaction => {
      return app.service('message').create({ text: "a new record" }, { sequelize: { transaction}  })
         .then(res => {
           // console.log('Result', res);
         })
         .catch(err => {
           // console.log('Error', err);
     });
  })

[bmbariah]

Does anyone know how to do transactions for an entire service? Something like what feathers-knex has. LINK