I chose NPM as my package manager since it comes bundled with node and so I decided to try out NPM workspaces as my MonoRepo approach.

So here are my takeaways

1. Setup

• The NPM workspaces Monorepo has one root dir with one package.json which defines the workspaces, but besides this it is more or less empty. The package.json defines a workspace directory which contains the sub projects.
  As of now you can’t use npm init for this but have to create the main package.json manually.

  "name": "workspaces-example",
  "workspaces": [
    "packages/*"
  ],

• The sub projects each have their own package.json with all necessary dependencies for this specific project. The sub projects can be initialised by npm init -w packages/cli
• To add dependencies you can add the workspace to the npm add command and the dependency will be added to the respective package.json:
  npm add commander -w packages/cli
  To install dependencies, run npm i from the root directory. This will install all deps of all workspaces in a node_modules folder in the root directory, but none in the projects in the workspaces folder. This already is a win because it will avoid having dependency duplettes.
  However if you have conflicting versions of the same dependency in your packages, you will have a separate node_modules directory with the only the specific version for this single package.

2. Development

• Updating dependencies can happen just like adding dependencies:
  npm update commander -w packages/cli
• When you need different versions of a dependency in your workspaces, NPM will create a new node_modules folder in the one divergating workspace with only the dependency where you have the different version.
• When you need to share code between workspaces you can import code from one package of the workspaces in another package just as a normal dependency from the NPM registry.
  For example when you want to share types in a typescript project you can add a types workspace and just import in the other workspaces files.
  import {Name} from "types";
• It is probably good practice to add shortcut scripts to your main package.json to run commands of your workspaces. So you don’t need to change to the workspaces directory, which is of course still possible.

  "scripts": {
    "hello-cli": "npm --workspace=@workspaces-example/cli run hello",
    "hello-web": "npm --workspace=@workspaces-example/web run hello"
  }

3. Deploy

• Deploying from a Monrepo needs to take the different packages into account, which need to be deployed separately but from the same CI config.
  For Github Actions i used a path directive which changes to the package directory and runs instructions there.
  with:
path: packages/astro
• Other prefabricated actions like f.e. actions/deploy-pages have a
  working-directory: ./packages/astro
  directive which have the same effect.

You can check out the example project here: https://github.com/ivoba/npm-workspaces-example

One probably does not necessarily need a Monorepo for this example, but it is good to know that Monorepos are quite simple to achieve just with NPM, in case you need to.

FirstName,LastName,Email
Max,Mustermann,max@mustermann.de
Maxi,Hasnoemail,

With nodejs streams this is almost a one liner.

We will use the csv package from the CSV project which has some sophisticated packages to parse and transform csv data with nodejs streams.

npm install csv

We will further use node as ESM (ECMAScript modules) to be shiningly modern and so lets create a file: index.mjs
Note the .mjs extension, which will tell node to interprete this as ESM. (Since nodejs v12.20.0 && v14.13.0)

We import the packages and create the filesystem streams to read the file, then built a pipeline with the streams and the single steps to process the data and write the results into a new file.
Ok let’s go:

import {pipeline} from 'stream';
import {parse, transform, stringify} from 'csv';
import {createReadStream, createWriteStream} from 'fs';

pipeline(
  createReadStream(`./members.csv`),
  parse(),
  transform(data => data[2] !== '' ? data : null),
  stringify({}),
  createWriteStream(`./members_filtered.csv`),
  err => err ? console.error('Pipeline failed.', err) : console.log('Pipeline succeeded.')
);

That is all, folks! Here is the gist.

We now have filtered all rows where the email is empty and saved the remaining rows to members_filtered.csv file.

We also could have done this with only pipes but this is considered unsafe (https://stackoverflow.com/questions/58875655/whats-the-difference-between-pipe-and-pipeline-on-streams/60459320#60459320) since pipeline is an optimized stream handling with better cleanups and error handling.
Nevertheless for the sake of completeness, the pipes version:

import {parse, transform, stringify} from 'csv';
import {createReadStream, createWriteStream} from 'fs';

createReadStream(`./members.csv`)
  .pipe(parse())
  .pipe(transform(data => data[2] !== '' ? data : null))
  .pipe(stringify({}))
  .pipe(createWriteStream(`./members_filtered.csv`))
  .on('finish', data => console.log('Done'));

…and so it goes Asynchronous:

 for(var i = 0; i < loop.length; i++)
 {
	var proxy = http.createClient(PORT,SERVER);
	var request = proxy.request('GET', url, 
        {
            "host": SERVER
        });
	request.end();
	...
 }

fire, fire, fire, fire

… and so it dont, Synchronous then:

var proxy = http.createClient(PORT,SERVER);
 
for(var i = 0; i < loop.length; i++)
 {
	var request = proxy.request('GET', url, 
        {
            "host": SERVER
        });
	request.end();
	...
 }

point – shoot, point – shoot, point – shoot

well i didnt know that :)