Reactive Data Seep

Code utilizing Reactive Data Seep pattern looks like this:

await withLogger({ level: LogLevel.DEBUG }, async logger => {
  logger.info('Connecting to database');

  await withDatabase(
    {
      uri: 'postgresql://dbuser:secretpassword@database.server.com:3211/mydb',
    },
    async db => {
      logger.info('Starting HTTP server');

      await withHttpServer(async server => {
        server.dispatch(
          {
            path: '/api/user',
            method: 'GET',
          },
          async ({ request, response }) => {
            const id = parseInt(request.url.searchParams.get('id'));
            const user = await db.query('SELECT name, email FROM user WHERE id = :id', { id });

            response.setHeader('Content-Type', 'application/json');

            await response.send(JSON.stringify(user));
          },
        );
        server.dispatch(
          {
            path: '/api/user',
            method: 'PUT',
          },
          async ({ request, response }) => {
            const user = JSON.parse(await request.read());
            const { id } = await db.query('INSERT INTO user (name, email) VALUES (:name, :email) RETURNING id', user);

            response.setHeader('Content-Type', 'application/json');

            await response.send(JSON.stringify({ id }));
          },
        );
        server.dispatchError(
          {
            type: NotFoundError,
          },
          async ({ response, error }) => {
            response.setHeader('Content-Type', 'application/json');
            response.setStatus(404);

            await response.send(JSON.stringify({ error: String(error.message) }));
          },
        );
        server.dispatchError(async ({ response, error }) => {
          response.setHeader('Content-Type', 'application/json');
          response.setStatus(500);

          await response.send(JSON.stringify({ error: String(error) }));
        });

        await Promise.any([
          withSignal(
            {
              signal: 'SIGINT',
            },
            signal => {
              logger.info('SIGINT received');

              return Promise.reject(signal);
            },
          ),
          server.listen({ post: 8080 }),
        ]);
      });

      logger.info('HTTP server stopped');
    },
  );

  logger.info('Disconnected from database');
});

The pattern relies on variable scoping rules. In particular, the data inflow into outer scope seeps through other data faucets to inner scopes.

A data faucet function implementing this pattern accepts an asynchronous sink function as its last argument. A sink function accepts an inflow value as its only argument. The inflow value exists while the sink processing it. After that, the value is no longer valid.

Implementing this pattern does not require the knowledge or use of any third-party libraries or APIs. However, in more complicated scenarios the tools provided by this package may be of help.