@wordpress/env 6.0.0 → 8.0.0

package/lib/config/get-config-from-environment-vars.js

@@ -0,0 +1,106 @@
+'use strict';
+/**
+ * Internal dependencies
+ */
+const {
+	parseSourceString,
+	includeTestsPath,
+} = require( './parse-source-string' );
+const { checkPort, checkVersion, checkString } = require( './validate-config' );
+
+/**
+ * @typedef {import('./parse-source-string').WPSource} WPSource
+ */
+
+/**
+ * Environment variable configuration.
+ *
+ * @typedef WPEnvironmentVariableConfig
+ * @property {?number}                  port             An override for the development environment's port.
+ * @property {?number}                  testsPort        An override for the testing environment's port.
+ * @property {?WPSource}                coreSource       An override for all environment's coreSource.
+ * @property {?string}                  phpVersion       An override for all environment's PHP version.
+ * @property {?Object.<string, string>} lifecycleScripts An override for various lifecycle scripts.
+ */
+
+/**
+ * Gets configuration options from environment variables.
+ *
+ * @param {string} cacheDirectoryPath Path to the work directory located in ~/.wp-env.
+ *
+ * @return {WPEnvironmentVariableConfig} Any configuration options parsed from the environment variables.
+ */
+module.exports = function getConfigFromEnvironmentVars( cacheDirectoryPath ) {
+	const environmentConfig = {
+		port: getPortFromEnvironmentVariable( 'WP_ENV_PORT' ),
+		testsPort: getPortFromEnvironmentVariable( 'WP_ENV_TESTS_PORT' ),
+		lifecycleScripts: getLifecycleScriptOverrides(),
+	};
+
+	if ( process.env.WP_ENV_CORE ) {
+		environmentConfig.coreSource = includeTestsPath(
+			parseSourceString( process.env.WP_ENV_CORE, {
+				cacheDirectoryPath,
+			} ),
+			{ cacheDirectoryPath }
+		);
+	}
+
+	if ( process.env.WP_ENV_PHP_VERSION ) {
+		checkVersion(
+			'environment variable',
+			'WP_ENV_PHP_VERSION',
+			process.env.WP_ENV_PHP_VERSION
+		);
+		environmentConfig.phpVersion = process.env.WP_ENV_PHP_VERSION;
+	}
+
+	return environmentConfig;
+};
+
+/**
+ * Parses an environment variable which should be a port.
+ *
+ * @param {string} varName The environment variable to check (e.g. WP_ENV_PORT).
+ *
+ * @return {number} The parsed port number.
+ */
+function getPortFromEnvironmentVariable( varName ) {
+	if ( ! process.env[ varName ] ) {
+		return undefined;
+	}
+
+	const port = parseInt( process.env[ varName ] );
+
+	// Throw an error if it is not parseable as a number.
+	checkPort( 'environment variable', varName, port );
+
+	return port;
+}
+
+/**
+ * Parses the lifecycle script environment variables.
+ *
+ * @return {Object.<string, string>} The parsed lifecycle scripts.
+ */
+function getLifecycleScriptOverrides() {
+	const lifecycleScripts = {};
+
+	// Find all of the lifecycle script overrides and parse them.
+	const lifecycleEnvironmentVars = {
+		WP_ENV_LIFECYCLE_SCRIPT_AFTER_START: 'afterStart',
+		WP_ENV_LIFECYCLE_SCRIPT_AFTER_CLEAN: 'afterClean',
+		WP_ENV_LIFECYCLE_SCRIPT_AFTER_DESTROY: 'afterDestroy',
+	};
+	for ( const envVar in lifecycleEnvironmentVars ) {
+		const scriptValue = process.env[ envVar ];
+		if ( scriptValue === undefined ) {
+			continue;
+		}
+
+		checkString( 'environment variable', envVar, scriptValue );
+		lifecycleScripts[ lifecycleEnvironmentVars[ envVar ] ] = scriptValue;
+	}
+
+	return lifecycleScripts;
+}

package/lib/config/index.js

@@ -1,18 +1,20 @@
+'use strict';
 /**
  * Internal dependencies
  */
-const readConfig = require( './config' );
+const loadConfig = require( './load-config' );
 const { ValidationError } = require( './validate-config' );
 const dbEnv = require( './db-env' );
 
 /**
- * @typedef {import('./config').WPConfig} WPConfig
- * @typedef {import('./config').WPServiceConfig} WPServiceConfig
- * @typedef {import('./config').WPSource} WPSource
+ * @typedef {import('./load-config').WPConfig} WPConfig
+ * @typedef {import('./parse-config').WPRootConfig} WPRootConfig
+ * @typedef {import('./parse-config').WPEnvironmentConfig} WPEnvironmentConfig
+ * @typedef {import('./parse-source-string').WPSource} WPSource
  */
 
 module.exports = {
 	ValidationError,
-	readConfig,
+	loadConfig,
 	dbEnv,
 };

package/lib/config/load-config.js

@@ -0,0 +1,92 @@
+'use strict';
+/**
+ * External dependencies
+ */
+const path = require( 'path' );
+const fs = require( 'fs' ).promises;
+
+/**
+ * Internal dependencies
+ */
+const getCacheDirectory = require( './get-cache-directory' );
+const md5 = require( '../md5' );
+const { parseConfig, getConfigFilePath } = require( './parse-config' );
+const postProcessConfig = require( './post-process-config' );
+
+/**
+ * @typedef {import('./parse-config').WPRootConfig} WPRootConfig
+ * @typedef {import('./parse-config').WPEnvironmentConfig} WPEnvironmentConfig
+ */
+
+/**
+ * wp-env configuration.
+ *
+ * @typedef WPConfig
+ * @property {string}                               name                    Name of the environment.
+ * @property {string}                               configDirectoryPath     Path to the .wp-env.json file.
+ * @property {string}                               workDirectoryPath       Path to the work directory located in ~/.wp-env.
+ * @property {string}                               dockerComposeConfigPath Path to the docker-compose.yml file.
+ * @property {boolean}                              detectedLocalConfig     If true, wp-env detected local config and used it.
+ * @property {Object.<string, string>}              lifecycleScripts        Any lifecycle scripts that we might need to execute.
+ * @property {Object.<string, WPEnvironmentConfig>} env                     Specific config for different environments.
+ * @property {boolean}                              debug                   True if debug mode is enabled.
+ */
+
+/**
+ * Loads any configuration from a given directory.
+ *
+ * @param {string} configDirectoryPath The directory we want to load the config from.
+ *
+ * @return {WPConfig} The config object we've loaded.
+ */
+module.exports = async function loadConfig( configDirectoryPath ) {
+	const configFilePath = getConfigFilePath( configDirectoryPath );
+
+	const cacheDirectoryPath = path.resolve(
+		await getCacheDirectory(),
+		md5( configFilePath )
+	);
+
+	// Parse any configuration we found in the given directory.
+	// This comes merged and prepared for internal consumption.
+	let config = await parseConfig( configDirectoryPath, cacheDirectoryPath );
+
+	// Make sure to perform any additional post-processing that
+	// may be needed before the config object is ready for
+	// consumption elsewhere in the tool.
+	config = postProcessConfig( config );
+
+	return {
+		name: path.basename( configDirectoryPath ),
+		dockerComposeConfigPath: path.resolve(
+			cacheDirectoryPath,
+			'docker-compose.yml'
+		),
+		configDirectoryPath,
+		workDirectoryPath: cacheDirectoryPath,
+		detectedLocalConfig: await hasLocalConfig( [
+			configFilePath,
+			getConfigFilePath( configDirectoryPath, 'override' ),
+		] ),
+		lifecycleScripts: config.lifecycleScripts,
+		env: config.env,
+	};
+};
+
+/**
+ * Checks to see whether or not there is any configuration present in the directory.
+ *
+ * @param {string[]} configFilePaths The config files we want to check for existence.
+ *
+ * @return {Promise<boolean>} A promise indicating whether or not a local config is present.
+ */
+async function hasLocalConfig( configFilePaths ) {
+	for ( const filePath of configFilePaths ) {
+		try {
+			await fs.stat( filePath );
+			return true;
+		} catch {}
+	}
+
+	return false;
+}

package/lib/config/merge-configs.js

@@ -0,0 +1,105 @@
+'use strict';
+/**
+ * @typedef {import('./parse-config').WPEnvironmentConfig} WPEnvironmentConfig
+ */
+
+/**
+ * Deep-merges the values in the given service environment. This allows us to
+ * merge the wp-config.php values instead of overwriting them.
+ *
+ * @param {WPEnvironmentConfig} defaultConfig The default config options.
+ * @param {...string}           configs       The config options to merge.
+ *
+ * @return {WPEnvironmentConfig} The merged config object.
+ */
+module.exports = function mergeConfigs( defaultConfig, ...configs ) {
+	// Start with our default config object. This has all
+	// of the options filled out already and we can use
+	// that to make performing the merge easier.
+	let config = defaultConfig;
+
+	// Merge the configs
+	for ( const merge of configs ) {
+		config = mergeConfig( config, merge );
+	}
+
+	return config;
+};
+
+/**
+ * Merges a config object into another.
+ *
+ * @param {WPEnvironmentConfig} config  The config object to be merged into.
+ * @param {WPEnvironmentConfig} toMerge The config object to merge.
+ *
+ * @return {WPEnvironmentConfig} The merged config object.
+ */
+function mergeConfig( config, toMerge ) {
+	// Begin by updating any of the config options that the object already has.
+	for ( const option in config ) {
+		// We don't need to do anything if the merge source doesn't have a property to give.
+		if ( toMerge[ option ] === undefined ) {
+			continue;
+		}
+
+		switch ( option ) {
+			// Some config options are merged together instead of entirely replaced.
+			case 'config':
+			case 'mappings':
+			case 'lifecycleScripts': {
+				config[ option ] = Object.assign(
+					config[ option ],
+					toMerge[ option ]
+				);
+				break;
+			}
+
+			// Environment-specific config options are recursively merged.
+			case 'env': {
+				for ( const environment in config.env ) {
+					// Once again, we don't need to do anything if the merge source has nothing to give.
+					if ( toMerge.env[ environment ] === undefined ) {
+						continue;
+					}
+
+					config.env[ environment ] = mergeConfig(
+						config.env[ environment ],
+						toMerge.env[ environment ]
+					);
+				}
+				break;
+			}
+
+			default: {
+				config[ option ] = toMerge[ option ];
+				break;
+			}
+		}
+	}
+
+	// Next, add any new options that the config object doesn't already have.
+	for ( const option in toMerge ) {
+		// Environment-specific config options should be checked individually.
+		if ( option === 'env' ) {
+			for ( const environment in toMerge.env ) {
+				// The presence of the environment means it would have been merged above.
+				if ( config.env[ environment ] !== undefined ) {
+					continue;
+				}
+
+				config.env[ environment ] = toMerge[ environment ];
+			}
+
+			continue;
+		}
+
+		// As above, the presence of the option means it would have been merged above.
+		if ( config[ option ] !== undefined ) {
+			continue;
+		}
+
+		config[ option ] = toMerge[ option ];
+	}
+
+	return config;
+}