@saasak/tool-env 0.0.1

package/bin/index.js

@@ -0,0 +1,204 @@
+import minimist from 'minimist';
+import fs from 'fs-extra';
+import path from 'path';
+import { $ } from 'execa';
+
+const args = minimist(process.argv.slice(2));
+const __dirname = path.dirname(new URL(import.meta.url).pathname)
+const __root = path.resolve(__dirname, '..');
+
+// Here we fetch the target env from cli args
+const DEFAULT_ENV = 'dev';
+const targets = {
+	"development": "dev",
+	"dev": "dev",
+	"staging": "preprod",
+	"pp": "preprod",
+	"preprod": "preprod",
+	"prod": "production",
+	"production": "production",
+}
+const target = targets[args.target] || DEFAULT_ENV;
+
+// Here we fetch the master env.json file
+// from which we will build all the .env files
+const envPath = args.env || '.env.json';
+const maybeEnvFile = path.resolve(__root, envPath);
+const envFile = fs.existsSync(maybeEnvFile) ? maybeEnvFile : null;
+
+if (!envFile) {
+	console.error('No env file found.');
+	process.exit(1);
+}
+
+const envContent = fs.readFileSync(envFile, 'utf8');
+const env = JSON.parse(envContent);
+
+// Here we fetch the root package.json file
+// And all packages that live in the monorepo
+// So we can extract names and directories
+const rootPkgPath = path.resolve(__root, 'package.json');
+const rootPkgContent = fs.readFileSync(rootPkgPath, 'utf8');
+const rootPkg = JSON.parse(rootPkgContent);
+const scope = rootPkg.name.split('/')[0];
+
+const packageList = await $`pnpm ls -r --depth=-1`
+const packageDirs = packageList.stdout
+    .split('\n')
+    .filter((line) => !!line)
+    .map((line) => line.split(' ')[1]);
+
+const [_, ...depPkgs] = packageDirs;
+const deps = depPkgs.map((pkgDir) => {
+	const pkgFile = fs.readFileSync(path.join(pkgDir, 'package.json'));
+	const pkg = JSON.parse(pkgFile);
+	return {
+		name: pkg.name.replace(`${scope}/`, ''),
+		dir: pkgDir,
+	};
+}).concat({
+	name: 'root',
+	dir: __root,
+});
+
+const depsName = deps.map((dep) => dep.name);
+
+// Here we do a check to see if target env is described
+const allowedEnvs = env && env.envs && Array.isArray(env.envs) ? env.envs : [DEFAULT_ENV];
+const targetEnv = allowedEnvs.find((env) => env === target);
+if (!targetEnv) {
+	console.error(`Target env "${target}" is not allowed.`);
+	process.exit(1);
+}
+
+// Here we build the env object which will be used
+// and which contains all the variables for all packages
+const allEnvs = buildEnv(targetEnv, env, depsName);
+
+// Here we write the .env files for each package to disk
+// This should not influence the vcs state as those env files
+// should be ignored by it
+for await (const dep of deps) {
+	const pkgEnv = Object.entries(allEnvs[dep.name] || {})
+		.map(([key, value]) => `${key}=${value}`)
+		.join('\n')
+	console.log(`Writing env file for ${dep.name} in ${dep.dir} with target ${targetEnv}`);
+	await fs.writeFile(path.join(dep.dir, '.env'), pkgEnv);
+}
+
+// ========================================
+// Helpers for core logic
+// ========================================
+
+function buildEnv(target, env, names) {
+	const variablesForAllTargets = env.variables;
+	const overrides = env.overrides || {};
+	const sections = env.sections || {};
+
+	// For each variables, extract the value for the target env
+	const variables = Object.entries(variablesForAllTargets).reduce((acc, entry) => {
+		const [key, value] = entry;
+		return {
+			...acc,
+			[key]: value[target] || value['@@'] || ''
+		};
+	}, {});
+
+	// For each package, get all variables
+	// compute the overrides and merge them
+	// allVars is an object with the package name as key
+	// and the variables as value like so
+	// => { [name]: { [variable]: value } }
+	const allVars = names.reduce((acc, name) => {
+		acc[name] = {
+			...variables,
+			...parseOverrides(target, overrides[name], variables)
+		};
+
+		return acc;
+	}, {});
+
+	// For each package, get all dependencies of variables
+	// For instance and for clarity, backoffice can include all vars
+	// from the api, and the api can include all vars from the core
+	const allDeps = names.reduce((acc, name) => ({
+		...acc,
+		[name]: parseSectionDeps(name, sections).reverse()
+	}), {})
+
+	// For each package, get all variable names from the dependencies
+	// and from the package itself and merge them
+	const allSections = Object.entries(allDeps).reduce((acc, entry) => {
+		const [key, deps] = entry;
+
+		// For all deps, get the variable names
+		const depVars = deps.filter(Boolean).reduce((_acc, dep) => {
+			const vars = parseSectionVars(dep, sections)
+			return [..._acc, ...vars];
+		}, []);
+
+		// For the current section, get the variable names
+		const nameVars = parseSectionVars(key, sections)
+
+		// Merge all variables names, and for each variable name,
+		// get the value from the allVars object
+		return {
+			...acc,
+			[key]: [...depVars, ...nameVars].reduce((_acc, variable) => {
+				if (!allVars[key] || allVars[key][variable] === null) return _acc;
+
+				return { ..._acc, [variable]: allVars[key][variable] };
+			}, {})
+		};
+	}, {});
+
+
+	return allSections;
+}
+
+function parseOverrides(target, overrides, vars) {
+	if (!overrides) return {};
+
+	return Object.entries(overrides).reduce((acc, entry) => {
+		const [key, val] = entry;
+		const value = val[target] || val['@@'] || '';
+
+		if (value === null) return acc;
+
+		acc[key] = Array.isArray(value)
+			? value.map(v => vars[v] || v).join('')
+			: value
+		return acc;
+	}, {});
+}
+
+function parseSectionDeps(name, sections, collected = []) {
+	if (!sections || !sections[name]) return [];
+
+	const collectedWithSelf = Array.from(new Set([...collected, name]));
+	const deps = sections[name]
+		.filter((key) => key.startsWith('@@'))
+		.map((key) => key.split('@@')[1])
+		.filter((key) => !collectedWithSelf.includes(key));
+
+	if (!deps.length) return [];
+
+	const uniquelyCollected = Array.from(new Set([...collected, ...deps]));
+	return [
+		...deps,
+		...deps.map(
+			(dep) => parseSectionDeps(
+				dep,
+				sections,
+				uniquelyCollected
+			)
+		).flat(),
+	];
+}
+
+function parseSectionVars(name, sections) {
+	if (!sections || !sections[name]) return [];
+
+	return sections[name]
+		.filter((key) => !key.startsWith('@@'))
+}

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@saasak/tool-env",
+  "license": "MIT",
+  "version": "0.0.1",
+  "author": "dev@saasak.studio",
+  "description": "A small util to manage environment variables for your monorepo",
+  "keywords": [
+    "tool",
+    "node",
+    "env"
+  ],
+  "type": "module",
+  "main": "bin/index.js",
+  "bin": {
+    "wrenv": "bin/index.js"
+  },
+  "dependencies": {
+    "execa": "8.0.1",
+    "fs-extra": "11.2.0",
+    "minimist": "1.2.8"
+  }
+}