[DEVREL-29] allow pretty permalinks to be handled for rest endpoints by default

.github/tests/2-rest-url-fix.bats

@@ -0,0 +1,98 @@
+#!/usr/bin/env bats
+
+# wp wrapper function
+_wp() {
+  terminus wp -- ${SITE_ID}.dev "$@"
+}
+
+# Helper function to get REST URL via WP-CLI
+get_rest_url() {
+  _wp eval 'echo get_rest_url();'
+}
+
+# Helper function to get home_url path via WP-CLI
+get_home_url_path() {
+  _wp eval 'echo rtrim(parse_url(home_url(), PHP_URL_PATH) ?: "", "/");'
+}
+
+setup_suite() {
+  # Ensure WP is installed and we are in the right directory
+  _wp core is-installed || (echo "WordPress not installed. Run setup script first." && exit 1)
+}
+
+@test "Check REST URL with default (pretty) permalinks (after setup script flush)" {
+  run get_rest_url
+  assert_success
+  # Default setup script sets /%postname%/ and flushes.
+  # Expecting /wp/wp-json/ because home_url path should be /wp
+  assert_output --partial "/wp/wp-json/"
+}
+
+@test "Check REST URL with plain permalinks" {
+  # Set plain permalinks and flush
+  _wp option update permalink_structure '' --quiet
+  _wp rewrite flush --hard --quiet
+  run get_rest_url
+  assert_success
+  # With plain permalinks, expect ?rest_route= based on home_url
+  # Check if it contains the problematic /wp-json/wp/ segment (it shouldn't)
+  refute_output --partial "/wp-json/wp/"
+  # Check if it contains the expected ?rest_route=
+  assert_output --partial "?rest_route=/"
+
+  # Restore pretty permalinks for subsequent tests
+  _wp option update permalink_structure '/%postname%/' --quiet
+  _wp rewrite flush --hard --quiet
+}
+
+@test "Check REST URL with pretty permalinks *before* flush (Simulates new site)" {
+  # Set pretty permalinks *without* flushing
+  _wp option update permalink_structure '/%postname%/' --quiet
+  # DO NOT FLUSH HERE
+
+  # Check home_url path to confirm /wp setup
+  run get_home_url_path
+  assert_success
+  assert_output "/wp"
+
+  # Now check get_rest_url() - this is where the original issue might occur
+  run get_rest_url
+  assert_success
+  # Assert that the output *should* be the correct /wp/wp-json/ even before flush,
+  # assuming the fix (either integrated or separate filter) is in place.
+  # If the fix is NOT in place, this might output /wp-json/ and fail.
+  # If the plain permalink fix was active, it might output /wp/wp-json/wp/ and fail.
+  assert_output --partial "/wp/wp-json/"
+  refute_output --partial "/wp-json/wp/" # Ensure the bad structure isn't present
+
+  # Clean up: Flush permalinks
+  _wp rewrite flush --hard --quiet
+}
+
+@test "Access pretty REST API path directly with plain permalinks active" {
+  # Set plain permalinks and flush
+  _wp option update permalink_structure '' --quiet
+  _wp rewrite flush --hard --quiet
+
+  # Get the full home URL to construct the test URL
+  SITE_URL=$( _wp option get home )
+  # Construct the pretty-style REST API URL
+  # Note: home_url() includes /wp, so we append /wp-json/... directly
+  TEST_URL="${SITE_URL}/wp-json/wp/v2/posts"
+
+  # Make a curl request to the pretty URL
+  # -s: silent, -o /dev/null: discard body, -w '%{http_code}': output only HTTP code
+  # -L: follow redirects (we expect NO redirect, so this helps verify)
+  # We expect a 200 OK if the internal handling works, or maybe 404 if not found,
+  # but crucially NOT a 301/302 redirect.
+  run curl -s -o /dev/null -w '%{http_code}' -L "${TEST_URL}"
+  assert_success
+  # Assert that the final HTTP status code is 200 (OK)
+  # If it were redirecting, -L would follow, but the *initial* code wouldn't be 200.
+  # If the internal handling fails, it might be 404 or other error.
+  assert_output "200"
+
+  # Restore pretty permalinks for subsequent tests
+  _wp option update permalink_structure '/%postname%/' --quiet
+  _wp rewrite flush --hard --quiet
+}

.github/workflows/ci.yml

@@ -77,7 +77,7 @@ jobs:
       env:
         CI: 1
       run: |
-          bats -p -t .github/tests
+          bats -p -t .github/tests/1-test-update-php.bats
 
     - name: Create failure status artifact
       if: failure()

.github/workflows/playwright.yml → .github/workflows/test.yml

@@ -1,4 +1,4 @@
-name: WordPress Composer Playwright Tests
+name: WordPress Composer Tests
 on:
   pull_request:
     paths-ignore:
@@ -29,13 +29,16 @@ permissions:
 
 jobs:
 
-  playwright-single:
+  test-single:
     name: Single site
     runs-on: ubuntu-latest
 
     steps:
       - uses: actions/checkout@v4
 
+      - name: Install Bats
+        uses: bats-core/bats-action@2.0.0
+
       - name: Wait for status artifacts
         env:
           GH_TOKEN: ${{ github.token }}
@@ -154,18 +157,31 @@ jobs:
           SITE_URL: ${{ env.SITE_URL }}
         run: npm run test .github/tests/wpcm.spec.ts
 
+      - name: Run Bats tests for URL fixes (Single Site)
+        env:
+          SITE_ID: wpcm-playwright-tests
+          TERMINUS_TOKEN: ${{ secrets.TERMINUS_TOKEN }}
+        run: |
+          echo "Running REST URL Bats tests..."
+          terminus auth:login --machine-token="${TERMINUS_TOKEN}" || echo "Terminus already logged in."
+          # Corrected path to the test file
+          bats -p -t .github/tests/rest-url-fix.bats
+
       - name: Delete Site
         if: success()
         shell: bash
         run: terminus site:delete wpcm-playwright-tests -y
 
-  playwright-subdir:
+  test-subdir:
     name: Subdirectory multisite
     runs-on: ubuntu-latest
 
     steps:
       - uses: actions/checkout@v4
 
+      - name: Install Bats
+        uses: bats-core/bats-action@2.0.0
+
       - name: Wait for status artifacts
         env:
           GH_TOKEN: ${{ github.token }}
@@ -287,18 +303,35 @@ jobs:
           echo "Running Playwright tests on WordPress subdirectory subsite"
             npm run test .github/tests/wpcm.spec.ts
 
+      - name: Run Bats tests for URL fixes
+        # This step runs *after* the site setup, including the initial permalink flush.
+        # The Bats test itself handles permalink changes for specific test cases.
+        # We need to pass the SITE_ID to the Bats test environment so WP-CLI commands work via Terminus.
+        env:
+          SITE_ID: wpcm-subdir-playwright-tests
+          SUBSITE: foo
+          TERMINUS_TOKEN: ${{ secrets.TERMINUS_TOKEN }}
+        run: |
+          echo "Running REST URL Bats tests..."
+          # Ensure Terminus is logged in if needed by Bats WP-CLI calls
+          terminus auth:login --machine-token="${TERMINUS_TOKEN}" || echo "Terminus already logged in."
+          bats -p -t .github/tests/2-rest-url-fix.bats
+
       - name: Delete Site
         if: success()
         shell: bash
         run: terminus site:delete wpcm-subdir-playwright-tests -y
 
-  playwright-subdom:
+  test-subdom:
     name: Subdomain multisite
     runs-on: ubuntu-latest
 
     steps:
       - uses: actions/checkout@v4
 
+      - name: Install Bats
+        uses: bats-core/bats-action@2.0.0
+
       - name: Wait for status artifacts
         env:
           GH_TOKEN: ${{ github.token }}
@@ -464,3 +497,20 @@ jobs:
           SITE_URL: ${{ env.SUBDOMAIN_URL }}
           GRAPHQL_ENDPOINT: ${{ env.SUBDOMAIN_URL }}/wp/graphql
         run: npm run test .github/tests/wpcm.spec.ts
+
+      - name: Run Bats tests for URL fixes (Subdomain)
+        env:
+          SITE_ID: wpcm-subdom-playwright-tests
+          SUBSITE: foo
+          TERMINUS_TOKEN: ${{ secrets.TERMINUS_TOKEN }}
+        run: |
+          echo "Running REST URL Bats tests..."
+          terminus auth:login --machine-token="${TERMINUS_TOKEN}" || echo "Terminus already logged in."
+          # Corrected path to the test file
+          bats -p -t .github/tests/rest-url-fix.bats
+
+      - name: Delete Site
+        # Run always to ensure cleanup
+        if: always()
+        shell: bash
+        run: terminus site:delete wpcm-subdom-playwright-tests -y

web/app/mu-plugins/filters.php

@@ -3,7 +3,7 @@
  * Plugin Name: Pantheon WordPress Filters
  * Plugin URI:   https://github.com/pantheon-systems/wordpress-composer-managed
  * Description:  Filters for Composer-managed WordPress sites on Pantheon.
- * Version:      1.2.2
+ * Version:      1.2.3
  * Author:       Pantheon Systems
  * Author URI:   https://pantheon.io/
  * License:      MIT License
@@ -235,3 +235,149 @@ function __rebuild_url_from_parts( array $parts ) : string {
 		( isset( $parts['fragment'] ) ? str_replace( '/', '', "#{$parts['fragment']}" ) : '' )
 	);
 }
+
+/**
+ * REST API Plain Permalink Fix
+ *
+ * Extracts the REST API endpoint from a potentially malformed path.
+ * Handles cases like /wp-json/v2/posts or /wp-json/wp/v2/posts.
+ *
+ * @since 1.2.3
+ * @param string $path The URL path component.
+ * @return string The extracted endpoint (e.g., /v2/posts) or '/'.
+ */
+function __extract_rest_endpoint( string $path ) : string {
+	$rest_route = '/'; // Default to base route
+	$wp_json_pos = strpos( $path, '/wp-json/' );
+
+	if ( $wp_json_pos !== false ) {
+		$extracted_route = substr( $path, $wp_json_pos + strlen( '/wp-json' ) ); // Get everything after /wp-json
+		// Special case: Handle the originally reported '/wp-json/wp/' malformation
+		if ( strpos( $extracted_route, 'wp/' ) === 0 ) {
+			$extracted_route = substr( $extracted_route, strlen( 'wp' ) ); // Remove the extra 'wp'
+		}
+		// Ensure the extracted route starts with a slash
+		if ( ! $extracted_route && $extracted_route[0] !== '/' ) {
+			$extracted_route = '/' . $extracted_route;
+		}
+		$rest_route = $extracted_route ?: '/'; // Use extracted route or default to base
+	}
+	return $rest_route;
+}
+
+/**
+ * Builds the correct plain permalink REST URL.
+ *
+ * @since 1.2.3
+ * @param string $endpoint The REST endpoint (e.g., /v2/posts).
+ * @param string|null $query_str The original query string (or null).
+ * @param string|null $fragment The original fragment (or null).
+ * @return string The fully constructed plain permalink REST URL.
+ */
+function __build_plain_rest_url( string $endpoint, ?string $query_str, ?string $fragment ) : string {
+	$home_url = home_url(); // Should be https://.../wp
+	// Ensure endpoint starts with /
+	$endpoint = '/' . ltrim( $endpoint, '/' );
+	// Construct the base plain permalink URL
+	$correct_url = rtrim( $home_url, '/' ) . '/?rest_route=' . $endpoint;
+
+	// Append original query parameters (if any, besides rest_route)
+	if ( !empty( $query_str ) ) {
+		parse_str( $query_str, $query_params );
+		unset( $query_params['rest_route'] ); // Ensure no leftover rest_route
+		if ( ! empty( $query_params ) ) {
+			// Check if $correct_url already has '?' (it should)
+			$correct_url .= '&' . http_build_query( $query_params );
+		}
+	}
+	// Append fragment if present
+	if ( !empty( $fragment ) ) {
+		$correct_url .= '#' . $fragment;
+	}
+
+	// Use normalization helper if available
+	if ( function_exists( __NAMESPACE__ . '\\__normalize_wp_url' ) ) {
+		return __normalize_wp_url( $correct_url );
+	} else {
+		return $correct_url; // Return without full normalization as fallback
+	}
+}
+
+/**
+ * Corrects generated REST API URL when plain permalinks are active but WordPress
+ * incorrectly generates a pretty-permalink-style path. Forces the URL
+ * back to the expected ?rest_route= format using helpers.
+ *
+ * @since 1.2.3 // TODO: Update version before release
+ * @param string $url The potentially incorrect REST URL generated by WP.
+ * @return string The corrected REST URL in plain permalink format.
+ */
+function filter_force_plain_rest_url_format( string $url ) : string {
+	$parsed_url = parse_url($url);
+
+	// Check if it looks like a pretty permalink URL (has /wp-json/ in path)
+	// AND lacks the ?rest_route= query parameter.
+	$has_wp_json_path = isset( $parsed_url['path'] ) && strpos( $parsed_url['path'], '/wp-json/' ) !== false;
+	$has_rest_route_query = isset( $parsed_url['query'] ) && strpos( $parsed_url['query'], 'rest_route=' ) !== false;
+
+	if ( $has_wp_json_path && ! $has_rest_route_query ) {
+		// It's using a pretty path format when it shouldn't be.
+		$endpoint = __extract_rest_endpoint( $parsed_url['path'] );
+		return __build_plain_rest_url( $endpoint, $parsed_url['query'] ?? null, $parsed_url['fragment'] ?? null );
+	}
+
+	// If the URL didn't match the problematic pattern, return it normalized.
+    return __normalize_wp_url($url);
+}
+
+/**
+ * Handles incoming requests using a pretty REST API path format when plain
+ * permalinks are active. It sets the correct 'rest_route' query variable
+ * internally instead of performing an external redirect.
+ *
+ * @since 1.2.3
+ * @param \WP $wp The WP object, passed by reference.
+ */
+function handle_pretty_rest_request_on_plain_permalinks( \WP &$wp ) {
+	// Only run if it's not an admin request. Permalink structure checked by the hook caller.
+	if ( is_admin() ) {
+		return;
+	}
+
+	// Use REQUEST_URI as it's more reliable for the raw request path before WP parsing.
+	$request_uri = $_SERVER['REQUEST_URI'] ?? '';
+	// Get the path part before any query string.
+	$request_path = strtok($request_uri, '?');
+
+	// Define the pretty permalink base path we expect if pretty permalinks *were* active.
+	$home_url_path = rtrim( parse_url( home_url(), PHP_URL_PATH ) ?: '', '/' ); // e.g., /wp
+	$pretty_rest_path_base = $home_url_path . '/wp-json/'; // e.g., /wp/wp-json/
+
+	// Check if the actual request path starts with this pretty base.
+	if ( strpos( $request_path, $pretty_rest_path_base ) === 0 ) {
+		// Extract the endpoint part *after* the base.
+		$endpoint = substr( $request_path, strlen( $pretty_rest_path_base ) );
+		// Ensure endpoint starts with a slash, default to base if empty.
+		$endpoint = '/' . ltrim($endpoint, '/');
+		// If the result is just '/', set it back to empty string for root endpoint ?rest_route=/
+		$endpoint = ($endpoint === '/') ? '' : $endpoint;
+
+		// Check if rest_route is already set (e.g., from query string), if so, don't overwrite.
+		// This prevents conflicts if someone manually crafts a URL like /wp/wp-json/posts?rest_route=/users
+		if ( ! isset( $wp->query_vars['rest_route'] ) ) {
+			// Directly set the query variable for the REST API.
+			$wp->query_vars['rest_route'] = $endpoint;
+
+			// Optional: Unset other query vars WP might have incorrectly parsed.
+			// unset($wp->query_vars['pagename'], $wp->query_vars['error']);
+		}
+		// No redirect, no exit. Let WP continue processing with the modified query vars.
+	}
+}
+
+// Only add the REST URL *generation* fix and the request handler if plain permalinks are enabled.
+if ( ! get_option('permalink_structure') ) {
+	add_filter('rest_url', __NAMESPACE__ . '\\filter_force_plain_rest_url_format', 10, 1);
+	// Hook the request handling logic to parse_request. Pass the $wp object by reference.
+	add_action('parse_request', __NAMESPACE__ . '\\handle_pretty_rest_request_on_plain_permalinks', 1, 1);
+}