Don't call zx, yield commands to it

[romainPrignon]

Hey :)

Several yers ago, I made something similar to zx: https://github.com/romainPrignon/unshell

Back then, I decided to use generators and yield as a way to call shell commands.
You can use it like this:

// pause.js
module.exports = function * pause () {
	const ids = yield * fetchContainerIds()

	for(const id of ids) {
		yield `docker pause ${id}`
	}
}

function * fetchContainerIds () {
	const ids = yield `docker ps -q --no-trunc`

	return ids.split('\n').filter(Boolean)
}

unshell run pause.js

There are some advantages to use yield versus regular function calls:

• looks like "sync" even though we use async under the hood (see example 1)
• scripts are testable without mocking the library (just call the generator function)
• scripts are independents from the execution engine (think the yield keyword as interface)
  There could be multiple execution engine responding to yield keyword

There's also some drawbacks:

• Not possible to fire async commands and await later (see example 2)
• Every function yielding shell commands are "taint" as generator (like async/await)
  It could be a way to clearly distinct which function yield effect versus pure function

example 1

There is no need to await anything

const res = yield `sleep 1; echo 1` // res === 1

A Naive Promise.all implementation in the execution engine runs all the commands at the same time
There is no need to "await Promise.all" here
const res = yield [
	`sleep 1; echo 1`,
	`sleep 2; echo 2`
]

example 2

Because everything feel synchronous, we loose some control over the promise API

const res = yield `sleep 100; echo 100`
const res2 = yield `sleep 1; echo 1` // waiting for res to resolve...

versus

const res = $`sleep 100; echo 100`
const res2 = await `sleep 1; echo 1`
await res

What do you think about using yield in zx script ?
Can it solve some issue ? Is it necessary ?
Is there any other drawback ?

Looking forward to hearing from you :)

[antonmedv]

Hi 👋

Really interesting project. Nice work 👍

Here is a few points:

• The yield and the async are almost the same.
  Actually async can be implemented in terms of yield (see https://github.com/tj/co).
• Testing generators in this sense is indeed easier.
• What about command substitution from a security point of view? The zx uses a special function $.quote which applied for all arguments.

let file = 'foo; rm -rf ~'
await $`touch ${file}`

• Readability. The $ symbol usually used as prompt in shells. In scripts it highlights parts what will be "executed". (Take a look at your example with yield [...], what those strings are doing? What if Promise.any is preferred? Or Promise.race?)

[romainPrignon]

hey :)

Thanks for taking the time to give some feedbacks.
You're right, without Tagged Template string, it'll be hard to control input arguments

Yield could be used along $ to handle asynchronicity.
any and race could be achieved with: yield any([$foo, $bar]) or yield race([$foo, $bar])
but we are loosing the abstraction over async.
Maybe, the only point of using yield is to be decoupled from the command engine and better testability

I'll continue working on it to see if there's other benefit

[antonmedv]

For testing in zx it’s possible to switch shell to some dummy binary which echoes revived commands.