orc-scripts 1.2.0-pre.0

package/src/config/webpack.config.js

@@ -0,0 +1,103 @@
+const webpack = require("webpack");
+const path = require("path");
+const readPkgUp = require("read-pkg-up");
+const { parseEnv } = require("../utils");
+
+const { packageJson } = readPkgUp.sync({ normalize: false }) || {};
+
+const here = p => path.join(__dirname, p);
+
+const babelWhitelist = require("./babel-whitelist.json");
+
+const config = {
+	entry: [here("setAssetPath.js"), "url-polyfill", "core-js", "whatwg-fetch", path.resolve("./src/index.js")],
+	output: {
+		chunkFilename: "[id].[chunkhash].js",
+		filename: "bundle.js",
+		path: path.resolve(process.cwd(), "dist"),
+	},
+	resolve: {
+		alias: {},
+		modules: [
+			// Always resolve in local src and node_modules
+			path.resolve(process.cwd(), "src"),
+			path.resolve(process.cwd(), "node_modules"),
+		],
+		symlinks: false,
+	},
+	module: {
+		rules: [
+			{
+				resource: {
+					test: /\.js$/, // Only JavaScript files
+					or: [
+						// One of these conditions must be true
+						{ not: [/node_modules/] }, // No dependencies unless explicitly allowed by whitelist
+					].concat(
+						// Allowed by whitelist
+						babelWhitelist.map(
+							lib => new RegExp("node_modules(?:/|\\\\)" + lib.replace("/", "(?:/|\\\\)") + "(?:/|\\\\)"),
+						),
+					),
+				},
+				use: [
+					{
+						loader: "babel-loader",
+						options: require("./babelrc.js"),
+					},
+				],
+			},
+			{
+				test: /\.svg$/,
+				loader: "svg-inline-loader",
+			},
+			{
+				test: /\.(jpe?g|png|gif)$/i,
+				use: ["file-loader", "img-loader"],
+			},
+			{
+				test: /\.css$/i,
+				use: ["style-loader", "css-loader"],
+			},
+			{
+				test: /\.(woff|woff2)(\?v=\d+\.\d+\.\d+)?$/,
+				use: {
+					loader: "url-loader",
+					options: {
+						limit: 50000,
+					},
+				},
+			},
+		],
+	},
+	plugins: [
+		new webpack.DefinePlugin({
+			BUILD_ID: `"${process.env.BUILD_BUILDID}"`,
+			BUILD_NUMBER: `"${process.env.BUILD_BUILDNUMBER}"`,
+		}),
+	],
+};
+
+const locales = packageJson.locales;
+const overtureModule = packageJson.overtureModule;
+const dependencies = packageJson.dependencies;
+
+config.plugins.push(
+	new webpack.DefinePlugin({
+		SUPPORTED_LOCALES: JSON.stringify(locales && locales.length ? locales : null),
+		OVERTURE_MODULE: JSON.stringify((overtureModule && overtureModule.name) || ""),
+		DEPENDENCIES: JSON.stringify(dependencies || {}),
+	}),
+);
+
+if (parseEnv("NODE_ENV") === "production") {
+	config.devtool = "source-map";
+	config.mode = "production";
+} else {
+	config.devtool = "inline-source-map";
+	config.optimization = { usedExports: true };
+	config.plugins.push(new webpack.NamedModulesPlugin(), new webpack.HotModuleReplacementPlugin());
+	config.mode = "development";
+}
+
+module.exports = config;

package/src/index.js

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+
+require("dotenv").config();
+
+global.amOrcScripts = /orc-scripts$/.test(require("pkg-dir").sync() || "");
+
+let shouldThrow;
+try {
+	shouldThrow = Number(process.version.slice(1).split(".")[0]) < 10;
+} catch (error) {
+	// ignore
+}
+
+if (shouldThrow) {
+	const msg = "You must use Node version 10 or greater to use orc-scripts.";
+	throw new Error(msg);
+}
+
+require("./run-script");

package/src/run-script.js

@@ -0,0 +1,99 @@
+const path = require("path");
+const spawn = require("cross-spawn");
+const glob = require("glob");
+
+const [, , script, ...args] = process.argv;
+const executor = global.amOrcScripts ? "node" : process.argv[0];
+
+if (script) {
+	spawnScript();
+} else {
+	const scriptsPath = path.join(__dirname, "scripts/");
+	const scriptsAvailable = glob.sync(path.join(__dirname, "scripts", "*"));
+	// `glob.sync` returns paths with unix style path separators even on Windows.
+	// So we normalize it before attempting to strip out the scripts path.
+	const scriptsAvailableMessage = scriptsAvailable
+		.map(path.normalize)
+		.map(s =>
+			s
+				.replace(scriptsPath, "")
+				.replace(/__tests__/, "")
+				.replace(/\.js$/, ""),
+		)
+		.filter(Boolean)
+		.join("\n  ")
+		.trim();
+	const fullMessage = `
+Usage: orc-scripts [script] [parameters]
+Available Scripts:
+  ${scriptsAvailableMessage}
+Parameters:
+  All parameters depend on the script. See documentation in orc-scripts/docs.
+  `.trim();
+	console.log(`\n${fullMessage}\n`);
+}
+
+function getEnv() {
+	// this is required to address an issue in cross-spawn
+	// https://github.com/kentcdodds/kcd-scripts/issues/4
+	return Object.keys(process.env)
+		.filter(key => process.env[key] !== undefined)
+		.reduce(
+			(envCopy, key) => {
+				envCopy[key] = process.env[key];
+				return envCopy;
+			},
+			{
+				[`SCRIPTS_${script.toUpperCase()}`]: true,
+			},
+		);
+}
+
+function spawnScript() {
+	const relativeScriptPath = path.join(__dirname, "./scripts", script);
+	const scriptPath = attemptResolve(relativeScriptPath);
+
+	if (!scriptPath) {
+		throw new Error(`Unknown script "${script}".`);
+	}
+	const nodeArgs = [
+		"--preserve-symlinks",
+		"--preserve-symlinks-main",
+		"--icu-data-dir=node_modules" + path.sep + "full-icu",
+	];
+	const result = spawn.sync(executor, [...nodeArgs, scriptPath, ...args], {
+		stdio: "inherit",
+		env: getEnv(),
+	});
+
+	if (result.signal) {
+		handleSignal(result);
+	} else {
+		process.exit(result.status);
+	}
+}
+
+function attemptResolve(...resolveArgs) {
+	try {
+		return require.resolve(...resolveArgs);
+	} catch (error) {
+		return null;
+	}
+}
+
+function handleSignal(result) {
+	if (result.signal === "SIGKILL") {
+		console.log(
+			`The script "${script}" failed because the process exited too early. ` +
+				"This probably means the system ran out of memory or someone called " +
+				"`kill -9` on the process.",
+		);
+	} else if (result.signal === "SIGTERM") {
+		console.log(
+			`The script "${script}" failed because the process exited too early. ` +
+				"Someone might have called `kill` or `killall`, or the system could " +
+				"be shutting down.",
+		);
+	}
+	process.exit(1);
+}

package/src/scripts/build/cli.js

@@ -0,0 +1,43 @@
+const path = require("path");
+const { hasPkgProp, resolveBin, hasFile } = require("../../utils");
+const spawn = require("cross-spawn");
+
+const here = p => path.join(__dirname, p);
+
+const args = process.argv.slice(2);
+
+const useSpecifiedOutDir = args.includes("--out-dir");
+const outDir = useSpecifiedOutDir ? [] : ["--out-dir", "dist"];
+
+const copyFiles = args.includes("--no-copy-files") ? [] : ["--copy-files"];
+
+const useBuiltinConfig =
+	!args.includes("--presets") && (!hasFile(".babelrc") || !hasFile("babel.config.js")) && !hasPkgProp("babel");
+const config = useBuiltinConfig ? ["--presets", here("../../config/babel-preset.js")] : [];
+
+const verbosity = args.includes("--quiet") ? [] : ["--verbose"];
+
+const ignore = args.includes("--ignore") ? [] : ["--ignore", "**/*.test.js,**/__mocks__"];
+
+const babelUnacceptedArgs = ["--no-copy-files"];
+
+const filteredArgs = args.filter(arg => !babelUnacceptedArgs.includes(arg));
+
+const child = spawn(
+	resolveBin("@babel/cli", { executable: "babel" }),
+	[...outDir, ...copyFiles, ...ignore, ...verbosity, ...config, "src"].concat(filteredArgs),
+	{ stdio: "inherit" },
+);
+
+child.on("error", err => {
+	console.error("An error occurred:");
+	console.error(err);
+	process.exit(-1);
+});
+
+child.on("exit", exitCode => {
+	if (exitCode !== 0) {
+		console.error("Babel finished with non-zero exit code", exitCode);
+	}
+	process.exit(exitCode);
+});

package/src/scripts/build/index.js

@@ -0,0 +1,9 @@
+const { parseEnv } = require("../../utils");
+
+const isWebpack = parseEnv("BUILD_WEBPACK", false);
+
+if (isWebpack) {
+	require("./web");
+} else {
+	require("./cli");
+}

package/src/scripts/build/web.js

@@ -0,0 +1,24 @@
+const config = require("../../config/webpack.config");
+const webpack = require("webpack");
+
+const args = process.argv.slice(2);
+
+if (args.includes("--stats")) {
+	const BundleAnalyzerPlugin = require("webpack-bundle-analyzer").BundleAnalyzerPlugin;
+	config.plugins.push(new BundleAnalyzerPlugin());
+}
+
+webpack(config, (err, stats) => {
+	if (err) {
+		console.error(err.stack || err);
+		process.exit(-2);
+	}
+	console.log(
+		stats.toString({
+			colors: true,
+		}),
+	);
+	if (stats.hasErrors()) {
+		process.exit(-1);
+	}
+});

package/src/scripts/buildDep.js

@@ -0,0 +1,122 @@
+const util = require("util");
+const path = require("path");
+const readPkgUp = require("read-pkg-up");
+const makeDir = require("make-dir");
+const rimraf = util.promisify(require("rimraf"));
+const copyFile = util.promisify(require("ncp").ncp);
+const spawn = require("cross-spawn");
+
+let repos;
+const gitMatch = /^(git@github\.com:|https:\/\/)/;
+repos = process.argv.find(element => gitMatch.test(element));
+if (!repos) {
+	console.error("No target repository given");
+	process.exit(-11);
+}
+
+const gitBranchResult = spawn.sync("git", ["rev-parse", "--abbrev-ref", "HEAD"]);
+if (gitBranchResult.status !== 0) {
+	console.error(gitBranchResult.stderr.toString("utf-8"));
+	process.exit(-12);
+}
+const currentBranch = gitBranchResult.stdout.toString("utf-8").trim();
+
+const master = process.argv.includes("--master") || currentBranch === "master";
+let release;
+if (process.argv.includes("--release")) {
+	release = process.argv[process.argv.indexOf("--release") + 1];
+}
+
+const releaseBranch = master ? "master" : release ? "release/" + release : "develop";
+
+async function build(repos) {
+	const name = repos.match(/([^/]*)\.git$/)[1];
+	const folder = path.resolve(process.cwd(), "builds/" + name);
+	let pack;
+
+	const versionString = name + " " + releaseBranch;
+	console.log(`Building ${versionString} from repository ${repos}
+	in ${folder}`);
+
+	const { packageJson } = readPkgUp.sync({ normalize: false }) || {};
+	if (packageJson.scripts && packageJson.scripts.build) {
+		const buildResult = spawn.sync("npm", ["run", "build"]);
+		if (buildResult.status !== 0) {
+			console.error(buildResult.stderr.toString("utf-8"));
+			return -1;
+		}
+	}
+	const packResult = spawn.sync("npm", ["pack"]);
+	if (packResult.status !== 0) {
+		console.error(packResult.stderr.toString("utf-8"));
+		return -2;
+	}
+	const packName = packResult.stdout.toString("utf-8").trim();
+	console.log("Packaged to " + packName);
+
+	pack = path.resolve(process.cwd(), packName);
+	try {
+		try {
+			await rimraf(folder);
+		} catch (err) {
+			console.error(err.message);
+			return -3;
+		}
+
+		try {
+			await makeDir("builds");
+		} catch (_) {}
+
+		const releaseArgs = ["--branch", releaseBranch, "--single-branch"];
+
+		const gitResult = spawn.sync("git", ["clone", repos, ...releaseArgs, folder]);
+		if (gitResult.status !== 0) {
+			console.error(gitResult.stderr.toString("utf-8"));
+			return -4;
+		}
+		console.log("Git repository was cloned");
+
+		try {
+			await copyFile(path.resolve(folder, ".env.example"), path.resolve(folder, ".env"));
+		} catch (err) {
+			console.error(err.message);
+			return -5;
+		}
+
+		const installResult = spawn.sync("npm", ["install"], { cwd: folder });
+		if (installResult.status !== 0) {
+			console.error(installResult.stderr.toString("utf-8"));
+			return -6;
+		}
+		console.log("Dependencies installed");
+
+		const packInstallResult = spawn.sync("npm", ["install", pack], {
+			cwd: folder,
+		});
+		if (packInstallResult.status !== 0) {
+			console.error(packInstallResult.stderr.toString("utf-8"));
+			return -7;
+		}
+		console.log("Package installed");
+
+		const testResult = spawn.sync("npm", ["test", "--", "--no-watch"], {
+			cwd: folder,
+			stdio: "inherit",
+		});
+		if (testResult.status !== 0) {
+			return 1;
+		}
+
+		console.log("Tests passed");
+		return 0;
+	} finally {
+		if (pack) await rimraf(pack);
+	}
+}
+
+build(repos).then(returnCode => {
+	if (returnCode) {
+		console.log("Errors occurred.");
+	}
+	process.exit(returnCode);
+});

package/src/scripts/buildIconsSheet.js

@@ -0,0 +1,50 @@
+const path = require("path");
+const baseDir = path.resolve(process.cwd(), "src");
+const content = path.resolve(baseDir, "content");
+const icons = path.resolve(content, "icons");
+const fs = require("fs");
+
+const iconsSheet = path.resolve(content, "iconsSheet.svg");
+
+const outStream = fs.createWriteStream(iconsSheet);
+outStream.addListener("open", () => {
+	outStream.write('<svg xmlns="http://www.w3.org/2000/svg">\n');
+	// Beware of any files with spaces in filenames, they're bad
+	const fileList = fs.readdirSync(icons).filter(file => file.endsWith(".svg"));
+
+	fileList.forEach(fileName => {
+		const pathToIcon = path.resolve(icons, fileName);
+
+		const fileNameWithoutExtension = fileName.replace(".svg", "");
+
+		const svgContent = fs.readFileSync(pathToIcon).toString();
+
+		let strippedContent = svgContent
+			.replace("<svg", "<symbol")
+			.replace("</svg>", "</symbol>\n")
+			.replace("<symbol", `<symbol id="icon-${fileNameWithoutExtension}"`)
+			.replace(/width(.*)" /, "")
+			.replace(/height(.*)" /, "");
+
+		if (/<!-- no post-processing -->/g.test(strippedContent) === false) {
+			if (strippedContent.includes('fill="none"') === false) {
+				strippedContent = strippedContent.replace(/fill="(.*?)"/, "");
+			}
+
+			if (strippedContent.includes("stroke") === false) {
+				console.log(fileNameWithoutExtension + ": adding stroke=none");
+				strippedContent = strippedContent.replace(/<path /gm, '<path stroke="none" ');
+			} else {
+				strippedContent = strippedContent.replace(/stroke="(.*?)"/, "");
+			}
+		} else {
+			console.log(fileNameWithoutExtension + ": skipping post-processing");
+		}
+
+		strippedContent = strippedContent.replace(/\s*<!--\s*no post-processing\s*-->\s*/gm, "");
+		strippedContent = strippedContent.replace(/^\s*[\r\n]/gm, "").replace(/  +/g, " ");
+
+		outStream.write(strippedContent);
+	});
+	outStream.end("</svg>");
+});

package/src/scripts/clean.js

@@ -0,0 +1,8 @@
+const path = require("path");
+const rimraf = require("rimraf");
+rimraf(path.resolve(process.cwd(), "dist"), err => {
+	if (err) {
+		console.error(err);
+		process.exit(1);
+	}
+});

package/src/scripts/extract-messages.js

@@ -0,0 +1,22 @@
+const path = require("path");
+const readPkgUp = require("read-pkg-up");
+const extractReactIntlMessages = require("extract-react-intl-messages");
+
+const { packageJson } = readPkgUp.sync({ normalize: false }) || {};
+const locales = packageJson.locales.map(l => l.cultureIso);
+
+if (!locales.length) {
+	console.error("Current project has no specified locales");
+	process.exit(-1);
+}
+
+console.log("Extracting react-intl messages for", locales.join(", "));
+console.log("Default locale is", locales[0]);
+
+const baseDir = path.resolve(process.cwd(), "src");
+const input = path.join(baseDir, "**", "!(*.test).js");
+const buildDir = path.resolve(baseDir, "translations");
+
+extractReactIntlMessages(locales, input, buildDir, {
+	defaultLocale: locales[0],
+});

package/src/scripts/generateApi.js

@@ -0,0 +1,152 @@
+const fs = require("fs");
+const https = require("https");
+const lodash = require("lodash");
+
+const occUrl = process.env.OccUrl;
+const occToken = process.env.OccToken;
+let outputFile = "";
+
+if (process.argv.includes("--outputFile")) {
+	outputFile = process.argv[process.argv.indexOf("--outputFile") + 1];
+}
+
+if (!outputFile) {
+	throw new Error("Missing --outputFile 'file' argument.");
+}
+
+if (!occToken) {
+	throw new Error(
+		"Missing OccToken environment variable. This environment variable needs to contains the authentication token used to access the OCC platform specified in OccUrl.",
+	);
+}
+
+if (!occUrl) {
+	throw new Error(
+		"Missing OccUrl environment variable. This environment variable needs to contains the URL of the OCC platform which contains the OpenAPI metadata.",
+	);
+}
+
+function uncapitalizeFirstLetter(s) {
+	return s.charAt(0).toLowerCase() + s.slice(1);
+}
+
+function extractRequestNameFromOperation(operation) {
+	const rx = /.*{(?<name>[^{}]*)}$/;
+	return uncapitalizeFirstLetter(operation.summary.match(rx).groups["name"]);
+}
+
+function isVerbAllowed(verb) {
+	const lowerCaseVerb = verb.toLowerCase();
+	return lowerCaseVerb === "get" || lowerCaseVerb === "post" || lowerCaseVerb === "put" || lowerCaseVerb === "delete";
+}
+
+function generateOperationsFromPath(url, pathData) {
+	const operations = [];
+
+	for (const verb of Object.getOwnPropertyNames(pathData)) {
+		if (!isVerbAllowed(verb)) {
+			continue;
+		}
+
+		const operation = pathData[verb];
+
+		operations.push({
+			name: extractRequestNameFromOperation(operation),
+			url: url,
+			verb: verb.toUpperCase(),
+			hasQueryString: operation.parameters.filter(p => p.in === "query").length > 0,
+		});
+	}
+
+	return operations;
+}
+
+function generateOperation(operation) {
+	// trim '/' from start/end and split on the '/' character. We do this to avoid having an empty element in the array
+	const urlSegments = lodash.trim(operation.url, "/").split("/");
+	const parameters = [];
+	const buildUrlParams = [];
+
+	// An OCC URL has the following format: /customers/{ScopeId}/{CustomerId}/orders
+	// The code below extract the tokens between curly braces and generates the parameters for the buildUrl method
+
+	for (const segment of urlSegments) {
+		if (segment.startsWith("{")) {
+			const cleanName = uncapitalizeFirstLetter(segment.match(/{(?<name>[^{}]*)}/).groups["name"]);
+			parameters.push(cleanName);
+			buildUrlParams.push(cleanName);
+		} else {
+			buildUrlParams.push(`"${segment}"`);
+		}
+	}
+
+	let buildUrlParamsStr = `[${buildUrlParams.join(", ")}]`;
+
+	if (operation.hasQueryString) {
+		parameters.push("queryParams");
+		buildUrlParamsStr += ", queryParams";
+	}
+
+	return `export const ${operation.name} = {
+\tname: '${operation.name}',
+\tbuildUrl: (${parameters.join(", ")}) => buildUrl(${buildUrlParamsStr}),
+\tverb: '${operation.verb}'
+}\n\n`;
+}
+
+function generateImports() {
+	if (fs.existsSync("node_modules/orc-shared")) {
+		return 'import { buildUrl } from "orc-shared/src/utils/buildUrl";\n\n';
+	}
+
+	return 'import { buildUrl } from "../utils/buildUrl";\n\n';
+}
+
+https
+	.get(occUrl, { headers: { "X-AUTH": occToken } }, resp => {
+		let data = "";
+		let error = "";
+
+		if (resp.statusCode !== 200) {
+			error = new Error(`Request Failed. Status Code: ${resp.statusCode}`);
+		}
+		if (error) {
+			console.error(error.message);
+			// Consume response data to free up memory
+			resp.resume();
+			return;
+		}
+
+		// A chunk of data has been received.
+		resp.on("data", chunk => {
+			data += chunk;
+		});
+
+		// The whole response has been received. Print out the result.
+		resp.on("end", () => {
+			const swaggerMetaData = JSON.parse(data);
+			const paths = swaggerMetaData.paths;
+			let operations = [];
+
+			for (const url of Object.getOwnPropertyNames(paths)) {
+				operations = operations.concat(generateOperationsFromPath(url, paths[url]));
+			}
+
+			let helperData = "/* istanbul ignore file */\n\n";
+			helperData += generateImports();
+
+			for (const op of lodash.sortBy(operations, [o => o.name])) {
+				helperData += generateOperation(op);
+			}
+
+			fs.writeFile(outputFile, helperData, function (err) {
+				if (err) {
+					return console.error(err);
+				}
+				console.log(`File '${outputFile}' has been created`);
+			});
+		});
+	})
+	.on("error", err => {
+		console.log("Error: " + err.message);
+	});

package/src/scripts/getDist.js

@@ -0,0 +1,20 @@
+const readPkgUp = require("read-pkg-up");
+const { prerelease } = require("semver");
+
+const { packageJson } = readPkgUp.sync({ normalize: false }) || {};
+const currentVersion = packageJson.version;
+const pre = prerelease(currentVersion);
+
+if (pre && pre[0] === "pre") {
+	console.log("beta");
+} else if (pre && pre[0] === "dev") {
+	console.log("dev");
+} else if (currentVersion.endsWith("+legacy")) {
+	console.log("previous");
+} else if (/^\d+\.\d+\.\d+$/.test(currentVersion)) {
+	console.log("latest");
+} else {
+	// This is not right?
+	console.log("trash");
+	console.error("Version number ", currentVersion, "does not comply with expectations");
+}