Make middleware with callback after handler

[BashkaMen]

Hello, I would like to have the ability to open a transaction and pass it in the request options. I think having something like this would be useful, even for use in other middlewares.

const db_tx_middleware = (level: IsolationLevel) => new Middleware({
    handler: async ({ input: req, options: opt, logger: logger }) => {
        const runner = db.createQueryRunner()
        await runner.connect()
        const manager = runner.manager;

        await runner.startTransaction(level)

        return {
            opts: { db_manager: runner.manager } // add to options
            dispose: async (ctx) => {
                if (ctx.error) {
                    await runner.rollbackTransaction()
                }
                else {
                    await runner.commitTransaction()
                }

                runner.release()
            }
        }
    }
})

But now I have to do everything in the handler.

const endpoint = defaultEndpointsFactory
    .build({
        input: request_schema,
        output: response_schema,
        handler: ({ input: req, options: opt }) => db_transaction('SERIALIZABLE', async db => {
            const user = await db.findOneBy(AppUser, { email: req.token })
            if (user) {
                const token = hash('sha256', req.token)
                return { jwt_token: token, roles: new Set([Role.Admin]) }
            }

            const email = `${randomUUIDv7()}@mail.com`;
            const new_user = AppUser.create(email);
            await db.save(new_user)

            const token = hash('sha256', req.token)
            return { jwt_token: token, roles: new Set([Role.RegularUser]) }
        })

    })

I also tried to do this using expressMiddleware, but it doesn't allow passing options.

[RobinTail]

@BashkaMen
I don't see you using db_tx_middleware for the endpoint. It should go before .build(). But anyway, what exactly is the problem? Options not coming to endpoint or something else?

[BashkaMen]

I need to add an instance of an open transaction (TypeORM EntityManager) to the options.

• After successful execution, commit the transaction.
• In case of an error, roll back the transaction.
• At the end of all actions, call opt.db.release() to return the connection to the pool.

[BashkaMen]

db_transaction в моем примере как middleware заворачивающий весь код в транзакцию
я бы хотел делать это так

defaultEndpointsFactory
    .addMiddleware(db_tx_middleware("SERIALIZABLE"))
    .build({
        input: request_schema,
        output: response_schema,
        handler: async ({ input: req, options: opt }) => {
            ...
        })

    })
    ```

[BashkaMen]

One more example for better understanding.

const db_tx_middleware = (level: IsolationLevel) => new Middleware({
    handler: async ({ input: req, options: opt, logger: logger }) => {
        const runner = db.createQueryRunner()
        await runner.connect()
        const manager = runner.manager;

        await runner.startTransaction(level)
        
        try
        {
            await my_endpoint(req, {...opt, db: manager })
            await runner.commitTransaction()
        } 
        catch (error) 
        {
            await runner.rollbackTransaction()
        }
        finally 
        {
           runner.release()
        }

    }
})

[RobinTail]

@BashkaMen ,

Middlewares are not supposed to call endpoints, they are supposed to be executed ahead of endpoint handlers.
However, middlewares can equip endpoint handlers with a context that the framework calls options.
Those options can contain such entities as transaction or even callbacks for either to commit or rollback.
If the endpoint handler throws, that error goes to ResultHandler.
You can make a custom one (instead of defaultResultHandler), which could also get those options and perform the rollback in case of an error.

So, here is the suggested architecture:

1. a Middleware that returns { commit, rollback } (callbacks),
2. a ResultHandler that in case of error takes rollback from options and calls it
3. a new EndpointsFactory() using that ResultHandler
4. an endpoint built on that EndpointsFactory with attached Middleware, doing the stuff and calling commit() from options or throwing.

const transactionMiddleware = new Middleware({
  handler: async () => ({
    commit: () => {},
    rollback: () => {},
  }),
});

const rh = new ResultHandler({
  positive: z.any(),
  negative: z.any(),
  handler: ({ options, error }) => {
    if (
      error &&
      "rollback" in options &&
      typeof options.rollback === "function"
    )
      options.rollback();
  },
});

const factory = new EndpointsFactory(rh);

const endpoint = factory.addMiddleware(transactionMiddleware).build({
  output: z.object({}),
  handler: async ({ options: { commit } }) => {
    /** do stuff or throw */
    commit();
    return {};
  },
});

[BashkaMen]

thanks for example