sync-threads

Make asynchronous calls in Node.js synchronously using worker threads and Atomics mutexes.

Especially useful when you need to resolve promises at require-time,
for example in an AWS Lambda function when using provisioned concurrency.

NOTE: you don't need this library if you're happy with the overhead of creating a Node.js subprocess,
see the Appendix for details.

Example

This example shows how we can synchronously retrieve secrets from AWS SSM
at require-time – that is, before the init stage of Lambda has finished.

index.js:

``js
const { createSyncFn } = require('sync-threads')

// Create our synchronous function
const getSsmSecretSync = createSyncFn('./worker.js')

// Call it at init (require) time, no async needed!
const secret = getSsmSecretSync('/my-secret')

// Logged at init time
console.log({ secret, source: 'init' })

exports.handler = async () => {
// This value can be used in our handler without needing to resolve anything async
console.log({ secret, source: 'handler' })
}
`

worker.js:

`js
const SSM = require('aws-sdk/clients/ssm')
const { runAsWorker } = require('sync-threads')

const ssm = new SSM()

runAsWorker(async (ssmParamName) => {
const {
Parameter: { Value },
} = await ssm.getParameter({ Name: ssmParamName, WithDecryption: true }).promise()
return Value
})
`

You can see this example, as well as how you'd bundle it if you're using webpack or similar, in the examples directory.

API

sync-threads exports two main functions: createSyncFn and runAsWorker

createSyncFn(filename[, bufferSize])

Returns a synchronous function that will run the specified file as a worker, pass in any arguments you give it, and wait for the result.

$3

To be called from inside your worker code. It will run the given asynchronous function with the given arguments from the parent and share the result.

Installation

With npm do:

`
npm install sync-threads
`

Appendix

You can achieve something very similar to this library using the
spawnSync/execSync functions from the child_process module in Node.js.

The main difference is that this library performs the async work in a thread, without creating a separate node process,
which makes it a little faster.

Here's a simple example of how you'd do it without needing this library:

index.js:

`js
const { execSync } = require('child_process')

const { secret } = JSON.parse(execSync('node worker.js /my-secret', 'utf8').trim().split('\n').pop())

console.log({ secret, source: 'init' })

exports.handler = async () => {
console.log({ secret, source: 'handler' })
}
`

worker.js:

`js
const SSM = require('aws-sdk/clients/ssm')

const ssm = new SSM()

;(async () => {
const {
Parameter: { Value },
} = await ssm.getParameter({ Name: process.argv[2], WithDecryption: true }).promise()
console.log('%j', { secret: Value })
})()
``