@elementor/wp-lite-env 0.0.12 → 0.0.14

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # wp-lite-env
 
+## 0.0.14
+
+### Patch Changes
+
+- 3060332: cjs build
+
+## 0.0.13
+
+### Patch Changes
+
+- 1753583: update tmpdir
+
 ## 0.0.12
 
 ### Patch Changes

package/__tests__/e2e.ts

@@ -1,19 +1,18 @@
-import {afterEach, describe, expect, test} from "@jest/globals";
+import {afterEach, beforeAll, describe, expect, test} from "@jest/globals";
 import {cleanup, generateFiles, getConfigFilePath, start, stop} from "../src/run";
 
 const port = '1234';
-const runPath = (port: string) => {
-    return generateFiles(port, getConfigFilePath(['', '', '', 'config=./tests/.wp-lite-env.json']));
-};
 
 describe('end to end tests', () => {
+    beforeAll(async () => {
+        generateFiles(port, getConfigFilePath(['', '', '', 'config=./tests/.wp-lite-env.json']));
+    })
     afterEach(async () => {
-        const theRunPath = runPath(port);
-        await stop(port, theRunPath);
-        cleanup(port, theRunPath);
+        await stop(port);
+        cleanup(port);
     }, 30000);
     test('WordPress is up and running', async () => {
-        await start( port, runPath(port) );
+        await start( port );
         const response = await fetch(`http://localhost:${port}`);
         expect(response.ok).toBe(true);
         expect(await response.text()).toContain('Welcome to WordPress');

package/dist/index.cjs

@@ -0,0 +1,309 @@
+#!/usr/bin/env node
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// index.ts
+var wp_lite_env_exports = {};
+__export(wp_lite_env_exports, {
+  cli: () => cli,
+  start: () => start,
+  stop: () => stop
+});
+module.exports = __toCommonJS(wp_lite_env_exports);
+
+// src/run.ts
+var import_docker_compose = require("docker-compose");
+var import_path2 = __toESM(require("path"), 1);
+
+// src/config.ts
+var import_fs = __toESM(require("fs"), 1);
+var getConfig = (configFilePath2) => {
+  let configFile = {};
+  if (configFilePath2) {
+    configFile = JSON.parse(import_fs.default.readFileSync(configFilePath2, "utf8"));
+  }
+  const defaultConfig = {
+    core: "6.7",
+    phpVersion: "8.1",
+    plugins: {},
+    themes: {},
+    mappings: {},
+    config: {}
+  };
+  return {
+    core: configFile.core || defaultConfig.core,
+    phpVersion: configFile.phpVersion || defaultConfig.phpVersion,
+    plugins: configFile.plugins || defaultConfig.plugins,
+    themes: configFile.themes || defaultConfig.themes,
+    mappings: configFile.mappings || defaultConfig.mappings,
+    config: configFile.config || defaultConfig.config
+  };
+};
+
+// src/run.ts
+var import_fs2 = __toESM(require("fs"), 1);
+
+// src/templates.ts
+var import_path = __toESM(require("path"), 1);
+var generateDockerComposeYmlTemplate = (config, basePath, port2, configPath) => {
+  const mappingsStringArray = Object.keys(config.mappings).map((key) => {
+    const value = config.mappings[key];
+    return `      - >-
+        ${import_path.default.resolve(basePath, value)}:/var/www/html/${key}
+`;
+  });
+  const pluginsStringArray = Object.keys(config.plugins).map((key) => {
+    const value = config.plugins[key];
+    return `      - >-
+        ${import_path.default.resolve(basePath, value)}:/var/www/html/wp-content/plugins/${key}
+`;
+  });
+  const themesStringArray = Object.keys(config.themes).map((key) => {
+    const value = config.themes[key];
+    return `      - >-
+        ${import_path.default.resolve(basePath, value)}:/var/www/html/wp-content/themes/${key}
+`;
+  });
+  const wpContent = `      - >-
+        wpcontent:/var/www/html
+`;
+  const wpConfig = `      - >-
+        ${configPath}:/var/www/html/wp-config
+`;
+  const volumes = mappingsStringArray.concat(pluginsStringArray).concat(themesStringArray).concat([wpContent, wpConfig]).join("");
+  return `services:
+  mysql:
+    image: 'mariadb:lts'
+    ports:
+      - '\${WP_ENV_MYSQL_PORT:-}:3306'
+    environment:
+      MYSQL_ROOT_HOST: '%'
+      MYSQL_ROOT_PASSWORD: password
+      MYSQL_DATABASE: wordpress
+    volumes:
+      - 'mysql:/var/lib/mysql'
+  wordpress:
+    depends_on:
+      - mysql
+    build:
+      context: .
+      dockerfile: WordPress.Dockerfile
+      no_cache: true
+      args: &ref_0
+        HOST_USERNAME: yotams
+        HOST_UID: '502'
+        HOST_GID: '20'
+    ports:
+      - '\${WP_ENV_PORT:-${port2}}:80'
+    environment:
+      APACHE_RUN_USER: '#502'
+      APACHE_RUN_GROUP: '#20'
+      WORDPRESS_DB_USER: root
+      WORDPRESS_DB_PASSWORD: password
+      WORDPRESS_DB_NAME: wordpress
+    volumes: &ref_1
+${volumes}
+    extra_hosts:
+      - 'host.docker.internal:host-gateway'
+  cli:
+    depends_on:
+      - wordpress
+    build:
+      context: .
+      dockerfile: CLI.Dockerfile
+      args: *ref_0
+    volumes: *ref_1
+    user: '502:20'
+    environment:
+      WORDPRESS_DB_USER: root
+      WORDPRESS_DB_PASSWORD: password
+      WORDPRESS_DB_NAME: wordpress
+    extra_hosts:
+      - 'host.docker.internal:host-gateway'
+volumes:
+  mysql: {}
+  wpcontent: {}
+`;
+};
+var generateWordPressDockerfileTemplate = (config) => {
+  return `FROM wordpress:${config.core}-php${config.phpVersion}
+ARG HOST_USERNAME
+ARG HOST_UID
+ARG HOST_GID
+# When the IDs are already in use we can still safely move on.
+RUN groupadd -o -g $HOST_GID $HOST_USERNAME || true
+RUN useradd -mlo -u $HOST_UID -g $HOST_GID $HOST_USERNAME || true
+`;
+};
+var generateCliDockerfileTemplate = (config) => {
+  return `FROM wordpress:cli-php${config.phpVersion}
+ARG HOST_USERNAME
+ARG HOST_UID
+ARG HOST_GID
+# When the IDs are already in use we can still safely move on.
+RUN addgroup -g $HOST_GID $HOST_USERNAME || true
+RUN useradd -mlo -u $HOST_UID -g $HOST_GID $HOST_USERNAME || true
+# RUN adduser -h /home/$HOST_USERNAME -G $( getent group $HOST_GID | cut -d: -f1 ) -u $HOST_UID $HOST_USERNAME || true
+
+# Have the container sleep infinitely to keep it alive for us to run commands on it.
+CMD [ "/bin/sh", "-c", "while true; do sleep 2073600; done" ]
+`;
+};
+var generateConfiguration = (config, port2) => {
+  const header = `#!/bin/bash
+set -eox pipefail
+`;
+  const configStringArray = Object.keys(config.config).map((key) => {
+    const value = config.config[key];
+    return `wp config set ${key} ${value} --raw`;
+  });
+  const wpCoreInstall = `wp core install --url="http://localhost:${port2}" --title="test" --admin_user=admin --admin_password=password --admin_email=wordpress@example.com --skip-email`;
+  return [header, wpCoreInstall].concat(configStringArray).join("\n");
+};
+
+// src/run.ts
+var import_crypto = require("crypto");
+var import_node_os = __toESM(require("os"), 1);
+var waitForServer = async (url, timeoutMs) => {
+  const startTime = Date.now();
+  const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+  while (startTime + timeoutMs > Date.now()) {
+    try {
+      const response = await fetch(url);
+      if (response.ok && (200 === response.status || 302 === response.status)) {
+        return true;
+      }
+    } catch (e) {
+    } finally {
+      await sleep(100);
+    }
+  }
+  return false;
+};
+var getRunPath = (port2) => import_path2.default.resolve(import_node_os.default.tmpdir(), port2);
+var start = async (port2) => {
+  const runPath = getRunPath(port2);
+  await (0, import_docker_compose.upAll)({
+    commandOptions: ["--build"],
+    composeOptions: ["-p", `port${port2}`],
+    cwd: runPath,
+    log: true
+  });
+  await waitForServer(`http://localhost:${port2}`, 1e4);
+  await cli(port2, "bash wp-config/configure-wp.sh");
+};
+var stop = async (port2) => {
+  const runPath = getRunPath(port2);
+  await (0, import_docker_compose.downAll)({
+    cwd: runPath,
+    commandOptions: ["--volumes", "--remove-orphans"],
+    composeOptions: ["-p", `port${port2}`],
+    log: true
+  });
+};
+var cli = async (port2, command2) => {
+  const runPath = getRunPath(port2);
+  await (0, import_docker_compose.run)("cli", command2, {
+    cwd: runPath,
+    commandOptions: ["--rm"],
+    composeOptions: ["-p", `port${port2}`],
+    log: true
+  });
+};
+var commandMap = {
+  start,
+  stop,
+  cli
+};
+var getWpConfigPath = (port2) => import_path2.default.resolve(process.cwd(), port2);
+var generateFiles = (port2, configFilePath2) => {
+  const config = getConfig(configFilePath2);
+  const wpConfigPath = getWpConfigPath(port2);
+  if (!import_fs2.default.existsSync(wpConfigPath)) {
+    import_fs2.default.mkdirSync(wpConfigPath, { recursive: true });
+  }
+  const wpConfig = generateConfiguration(config, port2);
+  import_fs2.default.writeFileSync(import_path2.default.resolve(wpConfigPath, "configure-wp.sh"), wpConfig);
+  const dockerComposeYmlTemplate = generateDockerComposeYmlTemplate(config, process.cwd(), port2, wpConfigPath);
+  const wordPressDockerfileTemplate = generateWordPressDockerfileTemplate(config);
+  const cliDockerfileTemplate = generateCliDockerfileTemplate(config);
+  const hash = (0, import_crypto.createHash)("sha256");
+  hash.update(dockerComposeYmlTemplate + wordPressDockerfileTemplate + cliDockerfileTemplate + port2);
+  const runPath = getRunPath(port2);
+  if (!import_fs2.default.existsSync(runPath)) {
+    import_fs2.default.mkdirSync(runPath);
+  }
+  console.log(`writing files to run path: ${runPath}`);
+  import_fs2.default.writeFileSync(import_path2.default.resolve(runPath, "docker-compose.yml"), dockerComposeYmlTemplate);
+  import_fs2.default.writeFileSync(import_path2.default.resolve(runPath, "WordPress.Dockerfile"), wordPressDockerfileTemplate);
+  import_fs2.default.writeFileSync(import_path2.default.resolve(runPath, "CLI.Dockerfile"), cliDockerfileTemplate);
+  return runPath;
+};
+var getArgument = (argumentKey, processArgs) => {
+  for (let i = 3; i < processArgs.length; i++) {
+    const argument = processArgs[i];
+    if (argument.startsWith(`${argumentKey}=`)) {
+      return argument.substring(argumentKey.length + 1);
+    }
+  }
+  return void 0;
+};
+var getConfigFilePath = (processArgs) => {
+  return import_path2.default.resolve(getArgument("config", processArgs));
+};
+var getCliCommand = (processArgs) => {
+  return getArgument("command", processArgs);
+};
+var getPort = (processArgs) => {
+  return getArgument("port", processArgs) || "8888";
+};
+var cleanup = (port2) => {
+  const runPath = getRunPath(port2);
+  import_fs2.default.rmSync(getWpConfigPath(port2), { recursive: true, force: true });
+  import_fs2.default.rmSync(runPath, { recursive: true, force: true });
+};
+
+// index.ts
+var command = process.argv[2];
+if (!commandMap[command]) {
+  console.log(`Valid commands: ${Object.keys(commandMap).join(", ")}. You used ${command}`);
+}
+var port = getPort(process.argv);
+var configFilePath = getConfigFilePath(process.argv);
+var cliCommand = getCliCommand(process.argv);
+generateFiles(port, configFilePath);
+commandMap[command](port, cliCommand).finally(() => {
+  cleanup(port);
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cli,
+  start,
+  stop
+});
+//# sourceMappingURL=index.cjs.map

package/dist/index.d.cts

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+declare const start: (port: string) => Promise<void>;
+declare const stop: (port: string) => Promise<void>;
+declare const cli: (port: string, command: string) => Promise<void>;
+
+export { cli, start, stop };

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
-declare const start: (port: string, runPath: string) => Promise<void>;
-declare const stop: (port: string, runPath: string) => Promise<void>;
-declare const cli: (port: string, runPath: string, command: string) => Promise<void>;
+declare const start: (port: string) => Promise<void>;
+declare const stop: (port: string) => Promise<void>;
+declare const cli: (port: string, command: string) => Promise<void>;
 
 export { cli, start, stop };

package/dist/index.js

@@ -169,27 +169,31 @@ var waitForServer = async (url, timeoutMs) => {
   }
   return false;
 };
-var start = async (port2, runPath2) => {
+var getRunPath = (port2) => path2.resolve(os.tmpdir(), port2);
+var start = async (port2) => {
+  const runPath = getRunPath(port2);
   await upAll({
     commandOptions: ["--build"],
     composeOptions: ["-p", `port${port2}`],
-    cwd: runPath2,
+    cwd: runPath,
     log: true
   });
   await waitForServer(`http://localhost:${port2}`, 1e4);
-  await cli(port2, runPath2, "bash wp-config/configure-wp.sh");
+  await cli(port2, "bash wp-config/configure-wp.sh");
 };
-var stop = async (port2, runPath2) => {
+var stop = async (port2) => {
+  const runPath = getRunPath(port2);
   await downAll({
-    cwd: runPath2,
+    cwd: runPath,
     commandOptions: ["--volumes", "--remove-orphans"],
     composeOptions: ["-p", `port${port2}`],
     log: true
   });
 };
-var cli = async (port2, runPath2, command2) => {
+var cli = async (port2, command2) => {
+  const runPath = getRunPath(port2);
   await run("cli", command2, {
-    cwd: runPath2,
+    cwd: runPath,
     commandOptions: ["--rm"],
     composeOptions: ["-p", `port${port2}`],
     log: true
@@ -214,15 +218,15 @@ var generateFiles = (port2, configFilePath2) => {
   const cliDockerfileTemplate = generateCliDockerfileTemplate(config);
   const hash = createHash("sha256");
   hash.update(dockerComposeYmlTemplate + wordPressDockerfileTemplate + cliDockerfileTemplate + port2);
-  const runPath2 = path2.resolve(os.tmpdir(), `${hash.digest("hex")}`);
-  if (!fs2.existsSync(runPath2)) {
-    fs2.mkdirSync(runPath2);
+  const runPath = getRunPath(port2);
+  if (!fs2.existsSync(runPath)) {
+    fs2.mkdirSync(runPath);
   }
-  console.log(`writing files to run path: ${runPath2}`);
-  fs2.writeFileSync(path2.resolve(runPath2, "docker-compose.yml"), dockerComposeYmlTemplate);
-  fs2.writeFileSync(path2.resolve(runPath2, "WordPress.Dockerfile"), wordPressDockerfileTemplate);
-  fs2.writeFileSync(path2.resolve(runPath2, "CLI.Dockerfile"), cliDockerfileTemplate);
-  return runPath2;
+  console.log(`writing files to run path: ${runPath}`);
+  fs2.writeFileSync(path2.resolve(runPath, "docker-compose.yml"), dockerComposeYmlTemplate);
+  fs2.writeFileSync(path2.resolve(runPath, "WordPress.Dockerfile"), wordPressDockerfileTemplate);
+  fs2.writeFileSync(path2.resolve(runPath, "CLI.Dockerfile"), cliDockerfileTemplate);
+  return runPath;
 };
 var getArgument = (argumentKey, processArgs) => {
   for (let i = 3; i < processArgs.length; i++) {
@@ -242,9 +246,10 @@ var getCliCommand = (processArgs) => {
 var getPort = (processArgs) => {
   return getArgument("port", processArgs) || "8888";
 };
-var cleanup = (port2, runPath2) => {
+var cleanup = (port2) => {
+  const runPath = getRunPath(port2);
   fs2.rmSync(getWpConfigPath(port2), { recursive: true, force: true });
-  fs2.rmSync(runPath2, { recursive: true, force: true });
+  fs2.rmSync(runPath, { recursive: true, force: true });
 };
 
 // index.ts
@@ -254,13 +259,11 @@ if (!commandMap[command]) {
 }
 var port = getPort(process.argv);
 var configFilePath = getConfigFilePath(process.argv);
-var runPath = generateFiles(port, configFilePath);
 var cliCommand = getCliCommand(process.argv);
-try {
-  await commandMap[command](port, runPath, cliCommand);
-} finally {
-  cleanup(port, runPath);
-}
+generateFiles(port, configFilePath);
+commandMap[command](port, cliCommand).finally(() => {
+  cleanup(port);
+});
 export {
   cli,
   start,

package/index.ts

@@ -10,11 +10,9 @@ if ( ! commandMap[ command ] ) {
 
 const port = getPort( process.argv );
 const configFilePath = getConfigFilePath( process.argv )
-const runPath = generateFiles( port, configFilePath );
 const cliCommand = getCliCommand( process.argv );
+generateFiles( port, configFilePath );
 
-try {
-	await commandMap[command](port, runPath, cliCommand);
-} finally {
-	cleanup( port, runPath );
-}
+commandMap[command](port, cliCommand).finally( () => {
+	cleanup( port );
+} );

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "@elementor/wp-lite-env",
-  "version": "0.0.12",
+  "version": "0.0.14",
   "private": false,
   "description": "A simple, lightweight, docker-based WordPress environment",
-  "main": "dist/index.js",
+  "main": "dist/index.cjs",
+  "module": "dist/index.js",
   "type": "module",
-  "types": "dist/index.d.ts",
+  "types": "dist/index.d.cts",
   "bin": {
-    "wp-lite-env": "dist/index.js"
+    "wp-lite-env": "dist/index.cjs"
   },
   "scripts": {
     "build": "tsup --config=./tsup.build.ts",
@@ -37,12 +38,12 @@
     "@eslint/js": "^9.15.0",
     "@jest/globals": "^29.7.0",
     "@types/eslint__js": "^8.42.3",
-    "@types/node": "^22.9.0",
+    "@types/node": "^22.10.0",
     "eslint": "~9.14.0",
     "jest": "^29.7.0",
     "ts-jest": "^29.2.5",
     "tsup": "^8.3.5",
     "typescript": "^5.6.3",
-    "typescript-eslint": "^8.14.0"
+    "typescript-eslint": "^8.16.0"
   }
 }

package/src/run.ts

@@ -30,7 +30,10 @@ const waitForServer = async ( url: string, timeoutMs: number ) => {
     return false;
 };
 
-export const start = async ( port: string, runPath: string ) => {
+const getRunPath = ( port: string ) => path.resolve( os.tmpdir(), port );
+
+export const start = async ( port: string ) => {
+    const runPath = getRunPath( port );
     await upAll( {
         commandOptions: [ '--build' ],
         composeOptions: [ '-p', `port${ port }` ],
@@ -38,10 +41,11 @@ export const start = async ( port: string, runPath: string ) => {
         log: true,
     } );
     await waitForServer( `http://localhost:${ port }`, 10000 );
-    await cli( port, runPath, 'bash wp-config/configure-wp.sh' );
+    await cli( port, 'bash wp-config/configure-wp.sh' );
 };
 
-export const stop = async ( port: string, runPath: string ) => {
+export const stop = async ( port: string ) => {
+    const runPath = getRunPath( port );
     await downAll( {
         cwd: runPath,
         commandOptions: [ '--volumes', '--remove-orphans' ],
@@ -50,7 +54,8 @@ export const stop = async ( port: string, runPath: string ) => {
     } );
 };
 
-export const cli = async ( port: string, runPath: string, command: string ) => {
+export const cli = async ( port: string, command: string ) => {
+    const runPath = getRunPath( port );
     await run( 'cli', command, {
         cwd: runPath,
         commandOptions: [ '--rm' ],
@@ -59,7 +64,7 @@ export const cli = async ( port: string, runPath: string, command: string ) => {
     } );
 };
 
-export const commandMap: { [key: string]: ( ( port: string ) => Promise<void> ) | ( ( port: string, runPath: string, command: string ) => Promise<void> ) } = {
+export const commandMap: { [key: string]: ( ( port: string ) => Promise<void> ) | ( ( port: string, command: string ) => Promise<void> ) } = {
     start,
     stop,
     cli,
@@ -84,7 +89,7 @@ export const generateFiles = ( port: string, configFilePath: string ) => {
     const cliDockerfileTemplate = generateCliDockerfileTemplate( config );
     const hash = createHash( 'sha256' );
     hash.update( dockerComposeYmlTemplate + wordPressDockerfileTemplate + cliDockerfileTemplate + port );
-    const runPath = path.resolve( os.tmpdir(), `${ hash.digest( 'hex' ) }` );
+    const runPath = getRunPath( port );
     if ( ! fs.existsSync( runPath ) ) {
         fs.mkdirSync( runPath );
     }
@@ -119,7 +124,8 @@ export const getPort = ( processArgs: string[] ) => {
     return getArgument( 'port', processArgs ) || '8888';
 };
 
-export const cleanup = ( port: string, runPath: string ) => {
+export const cleanup = ( port: string ) => {
+    const runPath = getRunPath( port );
     fs.rmSync( getWpConfigPath( port ), { recursive: true, force: true } );
     fs.rmSync( runPath, { recursive: true, force: true } );
 }

package/tsup.build.ts

@@ -3,7 +3,7 @@ import { defineConfig } from 'tsup';
 export default defineConfig( {
     entry: [ './index.ts' ],
     clean: true,
-    format: [ 'esm' ],
+    format: [ 'esm', 'cjs' ],
     sourcemap: true,
     dts: true,
 } );