Nginx WordPress Redirection Fix

networks:
wpbedrock:
driver: bridge

services:
# Nginx Service
nginx:
image: nginx:stable-alpine
container_name: ${APP_NAME}_nginx
ports:
– "2500:80"
links:
– php
volumes:
– ./bedrock:/var/www/html
– ./docker/nginx/site.conf:/etc/nginx/conf.d/default.conf:rw
– ./docker/logs/nginx:/var/logs/nginx:rw
depends_on:
– php
– mysql
networks:
– wpbedrock

# PHP Service
php:
build:
context: .
dockerfile: Dockerfile
container_name: ${APP_NAME}_php
volumes:
– ./bedrock:/var/www/html # Fixed typo in path
ports:
– "2501:9000"
networks:
– wpbedrock

# MySQL Service
mysql:
image: mysql:8.0
container_name: ${APP_NAME}_mysql_db
environment:
MYSQL_ROOT_PASSWORD: ${DB_ROOT_PASSWORD}
MYSQL_DATABASE: ${DB_NAME}
MYSQL_USER: ${DB_USER}
MYSQL_PASSWORD: ${DB_PASSWORD}
volumes:
– db_data:/var/lib/mysql
ports:
– "2502:3306"
networks:
– wpbedrock

# Adminer Service
adminer:
image: adminer
container_name: ${APP_NAME}_adminer
ports:
– "2530:8080"
restart: always
networks:
– wpbedrock

volumes:
db_data:
localhost:2500/wp/wp-admin redirect to localhost/wp/wp-admin'

### 1. Check WordPress Configuration
1. **Set Base URL in `.env` or `wp-config.php`**: If you haven’t already, define the URL in `wp-config.php` or in the `.env` file if you’re using Bedrock.
– In `wp-config.php`:

define('WP_HOME', 'http://localhost:2500');
     define('WP_SITEURL', 'http://localhost:2500/wp');

– Alternatively, if using `.env` in Bedrock, make sure to set:

WP_HOME=http://localhost:2500
     WP_SITEURL=http://localhost:2500/wp

### 2. Update Nginx Configuration
Check if the Nginx config in `docker/nginx/site.conf` is correctly set up for the WordPress Bedrock setup. Your `site.conf` file might look something like this:

server {
    listen 80;
    server_name localhost;
    root /var/www/html/web;

    index index.php index.html;

    location / {
        try_files $uri $uri/ /index.php?$args;
    }

    location ~ .php$ {
        fastcgi_pass php:9000;
        fastcgi_index index.php;
        include fastcgi_params;
        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
    }
}

Make sure the `root` directive points to the correct path for Bedrock (typically `/var/www/html/web`).

### 3. Restart Docker Containers
After making these changes, restart your Docker containers:

docker-compose down
docker-compose up -d

These steps should address the redirection issue by ensuring WordPress knows the correct base URL and that Nginx serves it from the right root directory. Let me know if this resolves it!

– **2501** is the port on your **host machine**.
– **9000** is the port inside the **Docker container**.

### Explanation of Port Mapping
When you map `2501:9000` in Docker, it means:

1. Any network traffic directed to `localhost:2501` on your host machine will be forwarded to port `9000` inside the `php` container.
2. This setup allows external services, like Nginx in your configuration, to connect to the PHP service by referencing `localhost:2501`.

### Usage in Your Setup
In your Docker Compose setup:
– **Port 9000** is typically used by PHP-FPM to listen for incoming FastCGI requests.
– Nginx can communicate with PHP-FPM on `php:9000` (inside the Docker network) to handle PHP processing.
– Mapping `2501` to `9000` also lets you connect to PHP-FPM from outside the Docker container if you need to, for example, to test connections or configure PHP-FPM settings directly.

### 1. Create the Missing Directory
You can create the necessary directories manually by running:

mkdir -p bedrock/web/app/cache/acorn/framework/cache

### 2. Set the Correct Permissions
Once the directory is created, you need to ensure it's writable by the web server user. In Docker, this often involves setting permissions within the container:

# Set write permissions for all users (adjust as necessary)
chmod -R 775 bedrock/web/app/cache/acorn/framework/cache

### 3. Update Permissions Inside the Docker Container (Optional)
If you're still experiencing issues, it might be helpful to set permissions directly inside the running container:

docker-compose exec php chmod -R 775 /var/www/html/web/app/cache/acorn/framework/cache

Or, if you need to set the owner to `www-data` (the typical user for web servers in Docker containers):

docker-compose exec php chown -R www-data:www-data /var/www/html/web/app/cache/acorn/framework/cache

### 4. Restart Docker (if needed)
Finally, restart your containers to make sure all changes take effect:

docker-compose down
docker-compose up -d

This setup should ensure that the cache directory is available and writable, resolving the error.

1. **List Directory Contents**
Use this command to check if the directory exists inside the PHP container:

docker-compose exec php ls -l /var/www/html/web/app/cache/acorn/framework

This will list all directories within `framework`. If the `cache` directory appears, it exists; if not, you'll need to create it.

2. **Check Directory Existence**
Alternatively, you can directly check if the `cache` directory exists with:

docker-compose exec php sh -c '[ -d /var/www/html/web/app/cache/acorn/framework/cache ] && echo "Directory exists" || echo "Directory does not exist"'

This command will return "Directory exists" if it’s there or "Directory does not exist" if it's missing.

Let me know if you need any more help with the setup!

1. **Create the Missing Directory Structure**
Run this command in your host terminal to create the necessary directory structure:

mkdir -p bedrock/web/app/cache/acorn/framework/cache

This will ensure that `acorn/framework/cache` exists within `bedrock/web/app/cache`.

2. **Verify Directory Creation**
After creating the directories on the host, you can check again inside the PHP container to ensure they’re mounted correctly. Run:

docker-compose exec php ls -l /var/www/html/web/app/cache/acorn/framework

3. **Set Permissions**
Once the directories exist, set the necessary permissions to make them writable, as previously discussed:

chmod -R 775 bedrock/web/app/cache/acorn/framework/cache

Or, to set permissions inside the Docker container, you can use:

docker-compose exec php chmod -R 775 /var/www/html/web/app/cache/acorn/framework/cache

After these steps, the full directory path should be in place, and it should be writable for Acorn and your WordPress installation. Let me know if this resolves the issue!

### 1. Verify Folder Structure on the Host
First, confirm the actual structure of `bedrock/web/app` on your host machine to ensure all directories (like `themes` and `plugins`) are present:

ls -l bedrock/web/app

If the expected folders are missing, you might need to add them manually or confirm that the installation was completed correctly.

### 2. Check Volume Mount in Docker
If the folders are present on your host but not showing in the container, the Docker volume may not be mounting correctly. Ensure the Docker Compose file correctly specifies the path. For example, verify the following line in your `docker-compose.yml` under the `php` service:

volumes:
  - ./bedrock:/var/www/html

### 3. Restart the Docker Containers
Sometimes, Docker volume changes might require a restart to take effect. Restart your containers:

docker-compose down
docker-compose up -d

### 4. Recheck the Folder Structure in the Container
After restarting, check the structure again inside the container to see if `themes` and `plugins` are now visible:

docker-compose exec php ls -l /var/www/html/bedrock/web/app

### 5. Confirm Permissions
Ensure that the permissions on the `bedrock/web/app` directory and its subdirectories are set correctly so Docker can access them:

chmod -R 775 bedrock/web/app

Let me know if this resolves the visibility issue for the `themes` and `plugins` folders.

ModuleError

✘ Could not resolve @roots/bud-hooks

ℹ Stack trace

│ at Module.resolve (./node_modules/@roots/bud-framework/lib/module.js:215:15)
│ at async Module.import (./node_modules/@roots/bud-framework/lib/module.js:132:13)
│ at async ./node_modules/@roots/bud-framework/lib/bootstrap.js:93:21
│ at async Promise.all (index 1)
│ at async bootstrap (./node_modules/@roots/bud-framework/lib/bootstrap.js:127:5)
│ at async Bud.initialize (./node_modules/@roots/bud-framework/lib/bud/index.js:116:9)
│ at async BudBuildCommand.makeBud (./node_modules/@roots/bud/lib/cli/commands/index.js:216:20)
│ at async BudBuildCommand.execute (./node_modules/@roots/bud/lib/cli/commands/build/index.js:76:9)
│ at async BudBuildCommand.validateAndExecute (./node_modules/clipanion/lib/advanced/Command.js:73:26)
│ at async Cli.run (./node_modules/clipanion/lib/advanced/Cli.js:229:24)

error Command failed with exit code 1.

Here are some steps to troubleshoot and potentially resolve this issue:

### 1. Ensure Dependencies Are Installed
It’s possible that the `@roots/bud-hooks` dependency wasn’t installed correctly. Try removing the `node_modules` directory and reinstalling dependencies:

rm -rf node_modules
yarn install

Then, try building again:

yarn run build

### 2. Check `@roots/bud-hooks` Version Compatibility
If you’re using a specific version of `@roots/bud`, ensure that all related packages (`@roots/bud-hooks`, `@roots/bud-framework`, etc.) are compatible with each other. To install a compatible version of `@roots/bud-hooks`, you can try:

yarn add @roots/bud-hooks

### 3. Update Bud and Roots Packages
If the issue persists, you may need to update your Bud dependencies to the latest versions:

yarn upgrade @roots/bud
yarn upgrade @roots/bud-hooks
yarn upgrade @roots/bud-framework

### 4. Clear Yarn Cache
Sometimes, Yarn’s cache can cause issues. Clear the cache and reinstall dependencies:

yarn cache clean
yarn install

### 5. Confirm Configuration Files
Ensure your Bud configuration files (e.g., `bud.config.js` or similar) don’t have any import statements referencing non-existent packages.

### 6. Test with a Clean Environment
If none of the above steps work, try removing any custom configuration temporarily to see if the build succeeds with a minimal setup.

After these steps, try running `yarn run build` again. Let me know if you encounter further issues.

Error [ERR_MODULE_NOT_FOUND]: Cannot find module '/var/www/html/web/app/themes/sagetheme/node_modules/lodash-es/add.js' imported from /var/www/html/web/app/themes/sagetheme/node_modules/lodash-es/lodash.js
at finalizeResolution (node:internal/modules/esm/resolve:265:11)
at moduleResolve (node:internal/modules/esm/resolve:933:10)
at defaultResolve (node:internal/modules/esm/resolve:1169:11)
at ModuleLoader.defaultResolve (node:internal/modules/esm/loader:383:12)
at ModuleLoader.resolve (node:internal/modules/esm/loader:352:25)
at ModuleLoader.getModuleJob (node:internal/modules/esm/loader:227:38)
at ModuleWrap. (node:internal/modules/esm/module_job:87:39)
at link (node:internal/modules/esm/module_job:86:36) {
code: 'ERR_MODULE_NOT_FOUND',
url: 'file:///var/www/html/web/app/themes/sagetheme/node_modules/lodash-es/add.js'
}

Node.js v20.15.1

### 1. Verify `lodash-es` Installation
Start by checking if `lodash-es` is properly installed in your project:

ls node_modules/lodash-es

If the folder is missing or incomplete, it’s likely that the package installation failed.

### 2. Reinstall Dependencies
Sometimes, simply reinstalling can fix missing modules. First, delete `node_modules` and reinstall:

rm -rf node_modules
yarn install

Then, try building again:

yarn run build

### 3. Ensure `lodash-es` Is Declared in `package.json`
If `lodash-es` isn’t listed in your `package.json`, add it directly:

yarn add lodash-es

### 4. Clear Yarn Cache and Reinstall
If issues persist, it may help to clear Yarn’s cache to avoid any cached errors:

yarn cache clean
yarn install

### 5. Check Node.js Version Compatibility
Ensure that your Node.js version is compatible with the Bud framework and your theme. Bud may require specific versions, so if possible, use Node.js 18 (LTS) instead of 20, as this can sometimes avoid compatibility issues.

To use Node.js 18 with `nvm` (Node Version Manager):

nvm install 18
nvm use 18

After completing these steps, try running `yarn run build` again. This should resolve the issue if it was due to a missing or incompatible `lodash-es` module. Let me know if the problem persists!

Here’s how you can install packages while ignoring peer dependencies:

### 1. Ignore Peer Dependencies During Installation

You can use the `–legacy-peer-deps` option to ignore peer dependencies temporarily:

yarn install --legacy-peer-deps

### 2. Disable Peer Dependency Warnings Globally (Yarn v2 or v3+)

If you’re using Yarn v2 or later, you can set Yarn to ignore peer dependencies globally in your project by configuring `.yarnrc.yml`:

1. Open or create a `.yarnrc.yml` file in your project root.
2. Add the following line to ignore peer dependencies:

ignorePeerDependencies: true

This setting will prevent Yarn from checking peer dependencies each time you run `yarn install`.

### 3. Use `–ignore-engines` for Version Mismatches

If you also encounter errors related to Node.js versions, you can use:

yarn install --ignore-engines

### 4. Ignore Peer Dependencies in Yarn v1

In Yarn v1, use the `–ignore-peer-deps` flag directly:

yarn install --ignore-peer-deps

### 5. Ignoring Peer Dependencies for a Specific Package

If you want to ignore peer dependencies only for a specific package, add the package with `–legacy-peer-deps`:

yarn add <package-name> --legacy-peer-deps

These options will allow you to install dependencies without blocking on peer dependency warnings. Let me know if this approach works for you!

### 1. Use a Separate Node.js Service
Instead of running the build in the PHP container, create a separate service in `docker-compose.yml` specifically for Node.js tasks like building assets. This way, you can run `yarn run build` in a container optimized for Node.js. Here’s an example:

services:
  # Node Service
  node:
    image: node:18-alpine # Use an appropriate Node version
    working_dir: /var/www/html
    volumes:
      - ./bedrock:/var/www/html

You can then run the build by accessing the Node container:

docker-compose run node yarn run build

### 2. Install Node.js in the PHP Container (If a Separate Service Isn’t Possible)
If you need to keep everything in the PHP container, you’ll want to:

1. Install Node.js and Yarn in the PHP container’s `Dockerfile`.
2. Adjust any necessary configurations.

In your `Dockerfile`:

# Install Node.js and Yarn
RUN curl -fsSL https://deb.nodesource.com/setup_18.x | bash - && 
    apt-get install -y nodejs && 
    npm install -g yarn

After updating the `Dockerfile`, rebuild the PHP container:

docker-compose build php

### 3. Run the Build Command Directly on Your Host Machine
If running the build in Docker isn’t a strict requirement, you could run `yarn run build` on your host machine to leverage its native performance.

Let me know if you try this setup or need further customization!

╭ sage [892d307770285fd0] ./public
│
│ │ css/app.3c2d0d.css from Css Minimizer plugin
│ │ Error: Cannot find module 'node_modules/caniuse-api/node_modules/caniuse-lite/dist/unpacker/index.js'. Please verify that the
│ │ package.json has a valid "main" entry
│ │ at Object. (node_modules/caniuse-api/dist/index.js:16:20)
│
│ │ css/editor.4f034e.css from Css Minimizer plugin
│ │ Error: Cannot find module 'node_modules/caniuse-api/node_modules/caniuse-lite/dist/unpacker/index.js'. Please verify that the
│ │ package.json has a valid "main" entry
│ │ at Object. (node_modules/caniuse-api/dist/index.js:16:20)
│
│ │ css/app.0c6aa2.css from Css Minimizer plugin
│ │ Error: Cannot find module 'node_modules/caniuse-api/node_modules/caniuse-lite/dist/unpacker/index.js'. Please verify that the
│ │ package.json has a valid "main" entry
│ │ at Object. (node_modules/caniuse-api/dist/index.js:16:20)
│
│ │ css/editor.cafc77.css from Css Minimizer plugin
│ │ Error: Cannot find module 'node_modules/caniuse-api/node_modules/caniuse-lite/dist/unpacker/index.js'. Please verify that the
│ │ package.json has a valid "main" entry
│ │ at Object. (node_modules/caniuse-api/dist/index.js:16:20)
│
╰ 4 errors

error Command failed with exit code 1.

### 1. Reinstall Dependencies
Start by removing the `node_modules` directory and reinstalling all dependencies to ensure everything is intact:

rm -rf node_modules
yarn install

### 2. Install `caniuse-api` Directly
If `caniuse-api` is listed in your dependencies but still causing issues, try reinstalling it directly:

yarn add caniuse-api

### 3. Check for `caniuse-lite`
Since the error is related to `caniuse-lite`, make sure it’s properly installed. You can add it manually if necessary:

yarn add caniuse-lite

### 4. Verify and Update Package Versions
Sometimes, version mismatches between dependencies can cause issues. Check the versions of your packages, particularly `caniuse-api`, and ensure compatibility. You can also update them:

yarn upgrade caniuse-api
yarn upgrade caniuse-lite

### 5. Clear Yarn Cache
If you continue to encounter issues, clearing Yarn's cache may help:

yarn cache clean
yarn install

### 6. Ensure Your Node Version is Compatible
Ensure you're using a compatible Node.js version. You mentioned using Node.js v20; you might want to switch to an LTS version like Node.js v18. You can use `nvm` to manage Node versions easily:

nvm install 18
nvm use 18

### 7. Review Your Build Process
Ensure that your build process (using Bud in this case) is set up correctly. Look for any custom configurations that might be impacting the build, especially in your `bud.config.js` or similar configuration files.

### 8. Manual Cleanup of `node_modules`
In some cases, if dependencies are deeply nested, a manual cleanup may be necessary:

1. Navigate to `node_modules/caniuse-api/node_modules/`.
2. Ensure that `caniuse-lite` exists. If it doesn’t, manually delete `node_modules/caniuse-api` and reinstall it.

After trying these steps, attempt to run `yarn run build` again. If the issue persists, please provide more details about your `package.json` and any relevant configurations, and I'll help you troubleshoot further!

### 1. Use a Separate Node.js Service
Creating a dedicated Node.js service in your Docker setup is the best way to enhance performance. Here’s how to modify your `docker-compose.yml` to include a separate Node.js service:

version: '3.8'

networks:
  wpbedrock:
    driver: bridge

services:
  # Nginx Service
  nginx:
    image: nginx:stable-alpine
    container_name: ${APP_NAME}_nginx
    ports:
      - "2500:80"
    links:
      - php
    volumes:
      - ./bedrock:/var/www/html
      - ./docker/nginx/site.conf:/etc/nginx/conf.d/default.conf:rw
      - ./docker/logs/nginx:/var/logs/nginx:rw
    depends_on:
      - php
      - mysql
    networks:
      - wpbedrock

  # PHP Service
  php:
    build:
      context: .
      dockerfile: Dockerfile
    container_name: ${APP_NAME}_php
    volumes:
      - ./bedrock:/var/www/html
    ports:
      - "2501:9000"
    networks:
      - wpbedrock 

  # Node Service
  node:
    image: node:18-alpine # Use an appropriate Node.js version
    working_dir: /var/www/html
    volumes:
      - ./bedrock:/var/www/html
    networks:
      - wpbedrock

  # MySQL Service
  mysql:
    image: mysql:8.0
    container_name: ${APP_NAME}_mysql_db
    environment:
      MYSQL_ROOT_PASSWORD: ${DB_ROOT_PASSWORD}
      MYSQL_DATABASE: ${DB_NAME}
      MYSQL_USER: ${DB_USER}
      MYSQL_PASSWORD: ${DB_PASSWORD}
    volumes:
      - db_data:/var/lib/mysql
    ports:
      - "2502:3306"
    networks:
      - wpbedrock

  # Adminer Service
  adminer:
    image: adminer
    container_name: ${APP_NAME}_adminer
    ports:
      - "2530:8080"
    restart: always
    networks:
      - wpbedrock

volumes:
  db_data:

### Running the Build Command
After adding the Node service, you can run your build command in the Node.js container instead of the PHP container:

docker-compose run node yarn run build

### 2. Optimize Node.js Container
You can further optimize the Node.js container:

– Use a lightweight Node.js image (like `node:18-alpine`).
– Ensure you have only the necessary packages installed in your `package.json` to reduce the build size.

### 3. Use `docker-compose exec`
If you prefer to run the build command in an already running Node.js container, you can start the containers and then execute:

docker-compose up -d # Start all services
docker-compose exec node yarn run build

### 4. Increase Resource Limits
If you are running Docker on a machine with limited resources, consider increasing the CPU and memory allocated to Docker in your settings. This can help speed up the build process.

### 5. Cache Node Modules
If your build process allows for caching (for example, using a build cache layer in your Dockerfile), consider leveraging that to speed up subsequent builds.

### 6. Review Build Configuration
Lastly, review your build configuration (e.g., `bud.config.js`) to ensure that there are no unnecessary tasks or configurations that could be slowing down the build.

By running the build process in a dedicated Node.js container, you should see a significant improvement in performance. Let me know if you have any questions or need further assistance!

### Updated `docker-compose.yml` Example

version: '3.8'

networks:
  wpbedrock:
    driver: bridge

services:
  # Nginx Service
  nginx:
    image: nginx:stable-alpine
    container_name: ${APP_NAME}_nginx
    ports:
      - "2500:80"
    links:
      - php
    volumes:
      - ./bedrock:/var/www/html
      - ./docker/nginx/site.conf:/etc/nginx/conf.d/default.conf:rw
      - ./docker/logs/nginx:/var/logs/nginx:rw
    depends_on:
      - php
      - mysql
    networks:
      - wpbedrock

  # PHP Service
  php:
    build:
      context: .
      dockerfile: Dockerfile
    container_name: ${APP_NAME}_php
    volumes:
      - ./bedrock:/var/www/html
    ports:
      - "2501:9000"
    networks:
      - wpbedrock 

  # Node Service
  node:
    image: node:20-alpine # Using Node.js 20 on Alpine
    working_dir: /var/www/html
    volumes:
      - ./bedrock:/var/www/html
    networks:
      - wpbedrock

  # MySQL Service
  mysql:
    image: mysql:8.0
    container_name: ${APP_NAME}_mysql_db
    environment:
      MYSQL_ROOT_PASSWORD: ${DB_ROOT_PASSWORD}
      MYSQL_DATABASE: ${DB_NAME}
      MYSQL_USER: ${DB_USER}
      MYSQL_PASSWORD: ${DB_PASSWORD}
    volumes:
      - db_data:/var/lib/mysql
    ports:
      - "2502:3306"
    networks:
      - wpbedrock

  # Adminer Service
  adminer:
    image: adminer
    container_name: ${APP_NAME}_adminer
    ports:
      - "2530:8080"
    restart: always
    networks:
      - wpbedrock

volumes:
  db_data:

### Running Your Build Command

After updating your `docker-compose.yml`, start your containers and run the build command inside the Node.js service:

1. **Start the services:**

docker-compose up -d

2. **Run the build command:**

docker-compose run node yarn run build

### Benefits of Using Node.js 20-Alpine

– **Lightweight:** The Alpine version is much smaller than standard Node.js images, which helps in faster builds and deployments.
– **Optimized Performance:** Node.js 20 offers improved performance over previous versions, so you should see better build times.

By using the dedicated Node service, you should experience a more responsive build process. If you encounter any further issues or have questions, feel free to ask!

### Updated `docker-compose.yml` Example with Latest Node.js

Here's how you might structure your `docker-compose.yml` file using the latest Node.js image:

version: '3.8'

networks:
  wpbedrock:
    driver: bridge

services:
  # Nginx Service
  nginx:
    image: nginx:stable-alpine
    container_name: ${APP_NAME}_nginx
    ports:
      - "2500:80"
    links:
      - php
    volumes:
      - ./bedrock:/var/www/html
      - ./docker/nginx/site.conf:/etc/nginx/conf.d/default.conf:rw
      - ./docker/logs/nginx:/var/logs/nginx:rw
    depends_on:
      - php
      - mysql
    networks:
      - wpbedrock

  # PHP Service
  php:
    build:
      context: .
      dockerfile: Dockerfile
    container_name: ${APP_NAME}_php
    volumes:
      - ./bedrock:/var/www/html
    ports:
      - "2501:9000"
    networks:
      - wpbedrock 

  # Node Service
  node:
    image: node:latest # Use the latest Node.js image
    working_dir: /var/www/html
    volumes:
      - ./bedrock:/var/www/html
    networks:
      - wpbedrock

  # MySQL Service
  mysql:
    image: mysql:8.0
    container_name: ${APP_NAME}_mysql_db
    environment:
      MYSQL_ROOT_PASSWORD: ${DB_ROOT_PASSWORD}
      MYSQL_DATABASE: ${DB_NAME}
      MYSQL_USER: ${DB_USER}
      MYSQL_PASSWORD: ${DB_PASSWORD}
    volumes:
      - db_data:/var/lib/mysql
    ports:
      - "2502:3306"
    networks:
      - wpbedrock

  # Adminer Service
  adminer:
    image: adminer
    container_name: ${APP_NAME}_adminer
    ports:
      - "2530:8080"
    restart: always
    networks:
      - wpbedrock

volumes:
  db_data:

### Running Your Build Command

1. **Start the services:**

docker-compose up -d

2. **Run the build command:**

docker-compose run node yarn run build

### Advantages of Using the Latest Node.js Image

– **Latest Features:** Using the latest version ensures you have access to the newest features, performance improvements, and security updates.
– **Better Compatibility:** If you’re using modern libraries or frameworks, the latest Node.js image is more likely to be compatible with them.

By running `yarn run build` in a dedicated Node.js container, you should experience better performance compared to running it in the PHP container. If you have any further questions or need assistance, feel free to ask!

### Example `.dockerignore`

# Ignore node_modules at the root level
node_modules
# Ignore vendor at the root level
vendor
# Ignore node_modules inside the bedrock directory
bedrock/node_modules
# Ignore vendor inside the bedrock directory
bedrock/vendor
# Ignore all node_modules folders anywhere under the bedrock directory
bedrock/**/node_modules

### Explanation

– **`node_modules`**: Ignores the `node_modules` folder located in the root directory of your project.
– **`vendor`**: Ignores the `vendor` directory located in the root directory of your project.
– **`bedrock/node_modules`**: Ignores the `node_modules` folder directly within the `bedrock` directory.
– **`bedrock/vendor`**: Ignores the `vendor` directory directly within the `bedrock` directory.
– **`bedrock/**/node_modules`**: Ignores all `node_modules` directories located anywhere within the `bedrock` directory, including nested directories.

### Finalizing the Setup

After creating or updating the `.dockerignore` file, be sure to:

1. Save the file in the root of your project (where your `docker-compose.yml` is located).
2. Rebuild your Docker containers to ensure the updated `.dockerignore` takes effect:

docker-compose build

This setup will help keep your Docker images clean and reduce build times by excluding unnecessary files and folders. If you have any other questions or need further modifications, let me know!

### Step 1: Update Your Docker Compose (If Needed)

Make sure your `docker-compose.yml` has a service for Node.js that maps the `web/app/themes` directory correctly. Here’s a reminder of how the Node service should look:

# Node Service
node:
  image: node:latest # Use the latest Node.js image
  working_dir: /var/www/html
  volumes:
    - ./bedrock:/var/www/html
  networks:
    - wpbedrock

### Step 2: Run the Build Command

1. **Navigate to the themes directory**: When executing the build command, specify the directory where your theme's `package.json` is located. For example, if your theme is named `your-theme`, the command will look like this:

docker-compose run node sh -c "cd web/app/themes/your-theme && yarn build"

### Step 3: Example Command Breakdown

– **`docker-compose run node`**: Runs a one-off command in the Node.js service defined in your `docker-compose.yml`.
– **`sh -c`**: Executes the following string as a shell command.
– **`cd web/app/themes/your-theme`**: Changes the directory to where your theme is located.
– **`&& yarn build`**: Executes the `yarn build` command after changing to the theme directory.

### Step 4: Verify the Build

After running the command, check the output to ensure that the build process completed successfully. If you encounter any errors, they will typically give you an indication of what went wrong (e.g., missing dependencies).

### Alternative: Using Docker Exec

If your Node.js container is already running, you can also execute the command directly inside the running container:

docker-compose exec node sh -c "cd web/app/themes/your-theme && yarn build"

This way, you avoid having to start a new container each time you want to build your theme.

### Note on Permissions

If you encounter permission issues while accessing files or directories, you may need to ensure that the user running the Node.js service has appropriate permissions to access the `bedrock` directory and its contents.

If you have further questions or run into issues, feel free to ask!

### Step 1: Ensure Bud is Installed

1. **Check your `package.json`**: Open your theme’s `package.json` file (located at `web/app/themes/your-theme/package.json`) and ensure that Bud is listed as a dependency. You should see something like this in the `dependencies` or `devDependencies` section:

"devDependencies": {
       "@roots/bud": "^x.x.x",
       "@roots/bud-cli": "^x.x.x",
       // other dependencies
   }

2. **Install Dependencies**: If Bud is listed but not installed, run the following command to install it:

docker-compose run node sh -c "cd web/app/themes/your-theme && yarn install"

### Step 2: Verify the Installation

Once the installation completes, check that Bud is installed:

docker-compose run node sh -c "cd web/app/themes/your-theme && yarn list --pattern @roots/bud"

This command will list the installed versions of Bud. If it’s installed correctly, you should see it in the output.

### Step 3: Running the Build Command Again

After confirming that Bud is installed, try running the build command again:

docker-compose run node sh -c "cd web/app/themes/your-theme && yarn run build"

### Step 4: Check Path and Environment

If you continue to encounter the same error:

1. **Check Your PATH**: Ensure that the `node_modules/.bin` directory is in your PATH. This is where Yarn places executables for locally installed packages. You can modify your build command to ensure it includes the path:

docker-compose run node sh -c "cd web/app/themes/your-theme && ./node_modules/.bin/bud build"

2. **Reinstall Node Modules**: Sometimes, reinstalling can fix issues related to missing binaries. Run:

docker-compose run node sh -c "cd web/app/themes/your-theme && rm -rf node_modules && yarn install"

### Step 5: Consult the Documentation

If the issue persists, consult the [Bud documentation](https://bud.js.org/docs) for any specific installation or configuration steps that might be required.

By following these steps, you should be able to resolve the issue with the Bud command not being found. If you have any other questions or need further assistance, let me know!