feature request: shorter commands for common patterns

[Zamiell]

Improvement 1 - Automatic Await

I predict that most uses of zx in the wild are people rewriting their Bash scripts into JavaScript/TypeScript.
For example, I imagine a common script might look something like this:

await $`npx tsc`;
await $`npx prettier .`;
await $`npx eslint .`;

It strikes me that this could be simplified. zx could automatically await every $ invocation. If it did that, then the code could be simplified to this:

$`npx tsc`;
$`npx prettier .`;
$`npx eslint .`;

Much better! However, I presume the downside to this approach is that we lose the ability to do background tasks. For example, the previous code might want to be written like:

const promises = [];
promises.push($`npx tsc`);
promises.push($`npx prettier .`);
promises.push($`npx eslint .`);
await Promise.all(promises);

So that's a problem. One idea is to parse the command for the & symbol, which would disable the awaiting behavior, like this:

const promises = [];
promises.push($`npx tsc &`);
promises.push($`npx prettier . &`);
promises.push($`npx eslint . &`);
await Promise.all(promises);

I chose the & symbol because that is the background execution operator in bash. In this setup, we get the best of both worlds.
Of course, this would be a breaking change and might disrupt the ecosystem. So, another idea is to add an option:

$.alwaysAwait = true;

Yet another idea/approach would be to use a separate symbol other than a dollar sign as an indication of "run a command like $, but always await it automatically". For example:

_`npx tsc`;
_`npx prettier .`;
_`npx eslint .`;

(Underscore and dollar sign are the only symbols that are valid as function names, so here I'll somewhat-arbitrarily choose underscore since dollar sign is taken.)

Improvement 2 - Automatic Output

It looks like this is a common pattern:

const foo = $(await $`foo`).toString();
const bar = $(await $`bar`).toString();

It strikes me that this could be abstracted further. Similar to my previous suggestion, it could be possible to add a symbol that is similar to $, but combines the await and toString parts. As an example, I'll arbitrarily choose the o letter, which is short for "output":

const foo = o`foo`;
const bar = o`bar`;

Another option is to use an underscore instead of o. Regardless, this would be a nice abstraction.

[antongolub]

A workaround for annoying await statements:

https://github.com/qiwi/thromise

[Zamiell]

Thanks. I read the readme of that package, but I'm not understanding how it would help to remove the boilerplate in the way that I describe in the OP.

[Zamiell]

Can you give an example of how it would work? Using this as an example:

await $`npx tsc`;
await $`npx prettier .`;
await $`npx eslint .`;

Also, I tried installing the package, but it doesn't seem to work:

[antongolub]

Oh, there was a broken typeref in the package:

qiwi/thromise#31
qiwi/thromise#32
https://github.com/qiwi/thromise/releases/tag/v1.5.2

[Zamiell]

@antongolub By moving it to a discussion, are you saying that this is a bad idea and that you won't accept PRs to add this functionality? The original intent of the issue was a code feature request, not to ask a question in a discussion format.

[antonmedv]

Before implementing a new API, a lot of consideration and thinking should be done. I will definitely not approve changes in the current form.

[Zamiell]

Ok, I see, you just want to discuss the possible APIs and do it in a discussion instead of an issue.

[antonmedv]

Another thing we are planning to add is $.sync method for zx v8 (#589).

[Zamiell]

The word "sync" does not appear on that page, so it might need to be added as a bullet point?

[antonmedv]

Updated the list.

[Zamiell]

I have been writing some zx scripts over the last few days. I have noticed that I have needed a good mixture of both sync, async, and "get output". So, a $.sync = true flag to always turn on sync mode is actually kind of annoying, because I would constantly have to toggle it back and forth. So thinking about this more, here's the API I would like to see:

1. s for a sync command. In other words:

s`foo`

Is equivalent to:

await $`foo`

2. a for an async command. In other words:

a`foo`

Is equivalent to:

$`foo`

3. o for sync output. In other words:

o`foo`

Is equivalent to:

(async $`foo`).toString()

The combination of these 3 things would allow us to create extremely concise scripts.

[Zamiell]

Another thing: #91 is spot on, having to do pipe all the time adds a huge amount of ugly verbosity to zx scripts. Like bsnux, I think that there should be some kind of option for zx to behave like Bash does out of the box. In fact, I would even go as so far as to say that this should be the default behavior for zx! It seems the point of zx is to emulate Bash scripts, so while it can never be a 1 to 1 replacement, the fact that command output will be suppressed seems like a big foot gun for brand new zx users.