@wp-typia/project-tools 0.11.1

package/templates/_shared/presets/test-preset/scripts/wait-for-wp-env.mjs.mustache

@@ -0,0 +1,102 @@
+#!/usr/bin/env node
+
+import wpEnvUtils from "./wp-env-utils.cjs";
+
+const { runWpCli } = wpEnvUtils;
+
+const baseUrl = process.argv[2] ?? "http://localhost:8889";
+const timeoutMs = Number.parseInt(process.argv[3] ?? "180000", 10);
+const wpEnvConfig = process.argv[4] ?? ".wp-env.test.json";
+const intervalMs = 2000;
+
+if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+	throw new Error(
+		`Invalid timeoutMs: ${process.argv[3] ?? "180000"}. Expected a positive integer.`,
+	);
+}
+
+const deadline = Date.now() + timeoutMs;
+const loginUrl = new URL("/wp-login.php", baseUrl).toString();
+
+function looksReady(html) {
+	return html.includes('id="loginform"') || html.includes('id="wpadminbar"');
+}
+
+function looksLikeInstall(html) {
+	return (
+		html.includes("install.php") ||
+		(html.includes("WordPress") && html.includes("Installation"))
+	);
+}
+
+function ensureWordPressInstalled(configPath) {
+	try {
+		runWpCli(["core", "is-installed"], { configPath });
+		return false;
+	} catch {
+		runWpCli(
+			[
+				"core",
+				"install",
+				`--url=${baseUrl}`,
+				`--title={{slug}}`,
+				"--admin_user=admin",
+				"--admin_password=password",
+				"--admin_email=admin@example.com",
+				"--skip-email",
+			],
+			{ configPath },
+		);
+		return true;
+	}
+}
+
+async function main() {
+	let lastStatus = "not-started";
+	let installAttempted = false;
+
+	while (Date.now() < deadline) {
+		try {
+			const response = await fetch(loginUrl, {
+				redirect: "follow",
+				headers: {
+					"cache-control": "no-cache",
+				},
+			});
+			const body = await response.text();
+
+			if (response.ok && looksReady(body)) {
+				console.log(`✅ wp-env ready at ${loginUrl}`);
+				return;
+			}
+
+			if (looksLikeInstall(body)) {
+				lastStatus = "install-screen";
+				if (!installAttempted) {
+					try {
+						const installed = ensureWordPressInstalled(wpEnvConfig);
+						installAttempted = installed;
+						lastStatus = installed ? "auto-installed" : "install-screen";
+					} catch (error) {
+						installAttempted = false;
+						lastStatus =
+							error instanceof Error ? error.message : "install-failed";
+					}
+				}
+			} else {
+				lastStatus = `http-${response.status}`;
+			}
+		} catch (error) {
+			lastStatus =
+				error instanceof Error ? error.message : "unknown-network-error";
+		}
+
+		await new Promise((resolve) => setTimeout(resolve, intervalMs));
+	}
+
+	throw new Error(
+		`Timed out waiting for wp-env login readiness at ${loginUrl} (last status: ${lastStatus})`,
+	);
+}
+
+await main();

package/templates/_shared/presets/test-preset/scripts/wp-env-utils.cjs.mustache

@@ -0,0 +1,32 @@
+const { execFileSync } = require("node:child_process");
+const path = require("node:path");
+
+const ROOT_DIR = path.resolve(__dirname, "..");
+const TEST_WP_ENV_CONFIG = ".wp-env.test.json";
+
+function getWpEnvCommand() {
+	return process.platform === "win32"
+		? path.join(ROOT_DIR, "node_modules", ".bin", "wp-env.cmd")
+		: path.join(ROOT_DIR, "node_modules", ".bin", "wp-env");
+}
+
+function runWpEnv(args, { cwd = ROOT_DIR } = {}) {
+	return execFileSync(getWpEnvCommand(), args, {
+		cwd,
+		encoding: "utf8",
+		shell: process.platform === "win32",
+		stdio: "pipe",
+	});
+}
+
+function runWpCli(args, { configPath = TEST_WP_ENV_CONFIG, cwd = ROOT_DIR } = {}) {
+	return runWpEnv(["run", "cli", `--config=${configPath}`, "wp", ...args], { cwd });
+}
+
+module.exports = {
+	ROOT_DIR,
+	TEST_WP_ENV_CONFIG,
+	getWpEnvCommand,
+	runWpCli,
+	runWpEnv,
+};

package/templates/_shared/presets/test-preset/tests/e2e/smoke.spec.ts.mustache

@@ -0,0 +1,34 @@
+import { expect, test } from "@playwright/test";
+
+const BLOCK_NAME = "{{namespace}}/{{slugKebabCase}}";
+const BLOCK_TITLE = "{{title}}";
+
+test("registers the scaffolded block in the WordPress editor", async ({ page }) => {
+	await page.goto("/wp-login.php");
+	await page.getByLabel("Username or Email Address").fill("admin");
+	await page.getByLabel("Password").fill("password");
+	await page.getByRole("button", { name: "Log In" }).click();
+
+	await page.goto("/wp-admin/post-new.php");
+	await page.waitForLoadState("networkidle");
+
+	await page.waitForFunction(
+		(blockName) => Boolean(window.wp?.blocks?.getBlockType(blockName)),
+		BLOCK_NAME,
+	);
+
+	const registeredBlock = await page.evaluate((blockName) => {
+		const block = window.wp?.blocks?.getBlockType(blockName);
+		return block
+			? {
+					name: block.name,
+					title: block.title,
+				}
+			: null;
+	}, BLOCK_NAME);
+
+	expect(registeredBlock).toEqual({
+		name: BLOCK_NAME,
+		title: BLOCK_TITLE,
+	});
+});

package/templates/_shared/presets/wp-env/.wp-env.json.mustache

@@ -0,0 +1,16 @@
+{
+  "$schema": "https://schemas.wp.org/trunk/wp-env.json",
+  "core": null,
+  "port": 8888,
+  "testsEnvironment": false,
+  "plugins": [
+    "."
+  ],
+  "config": {
+    "WP_DEBUG": true,
+    "WP_DEBUG_LOG": true,
+    "WP_DEBUG_DISPLAY": false,
+    "SCRIPT_DEBUG": true,
+    "WP_ENVIRONMENT_TYPE": "local"
+  }
+}

package/templates/_shared/rest-helpers/auth/inc/rest-auth.php.mustache

@@ -0,0 +1,37 @@
+<?php
+
+function {{phpPrefix}}_get_rest_nonce( WP_REST_Request $request ) {
+	$header_nonce = $request->get_header( 'X-WP-Nonce' );
+	if ( is_string( $header_nonce ) && '' !== $header_nonce ) {
+		return $header_nonce;
+	}
+
+	$query_nonce = $request->get_param( '_wpnonce' );
+	if ( is_string( $query_nonce ) && '' !== $query_nonce ) {
+		return $query_nonce;
+	}
+
+	return null;
+}
+
+// Customize authenticated write policy here when your project needs stricter capability checks.
+function {{phpPrefix}}_can_write_authenticated( WP_REST_Request $request ) {
+	if ( ! is_user_logged_in() ) {
+		return new WP_Error(
+			'rest_forbidden',
+			'Authentication is required to update this counter.',
+			array( 'status' => rest_authorization_required_code() )
+		);
+	}
+
+	$nonce = {{phpPrefix}}_get_rest_nonce( $request );
+	if ( ! is_string( $nonce ) || '' === $nonce || ! wp_verify_nonce( $nonce, 'wp_rest' ) ) {
+		return new WP_Error(
+			'rest_forbidden',
+			'The REST nonce is missing or invalid.',
+			array( 'status' => 403 )
+		);
+	}
+
+	return true;
+}

package/templates/_shared/rest-helpers/public/inc/rest-public.php.mustache

@@ -0,0 +1,314 @@
+<?php
+
+function {{phpPrefix}}_base64url_encode( $value ) {
+	return rtrim( strtr( base64_encode( $value ), '+/', '-_' ), '=' );
+}
+
+function {{phpPrefix}}_base64url_decode( $value ) {
+	if ( ! is_string( $value ) || '' === $value ) {
+		return false;
+	}
+
+	$padding = strlen( $value ) % 4;
+	if ( $padding > 0 ) {
+		$value .= str_repeat( '=', 4 - $padding );
+	}
+
+	return base64_decode( strtr( $value, '-_', '+/' ), true );
+}
+
+function {{phpPrefix}}_get_public_write_action() {
+	return '{{namespace}}/{{slugKebabCase}}/state/write';
+}
+
+function {{phpPrefix}}_get_public_write_client_subject() {
+	$remote_addr = isset( $_SERVER['REMOTE_ADDR'] ) && is_string( $_SERVER['REMOTE_ADDR'] )
+		? wp_unslash( $_SERVER['REMOTE_ADDR'] )
+		: '';
+	$user_agent  = isset( $_SERVER['HTTP_USER_AGENT'] ) && is_string( $_SERVER['HTTP_USER_AGENT'] )
+		? wp_unslash( $_SERVER['HTTP_USER_AGENT'] )
+		: '';
+
+	return md5( $remote_addr . '|' . $user_agent );
+}
+
+function {{phpPrefix}}_get_public_write_rate_limit_key( $post_id, $resource_key ) {
+	return '{{phpPrefix}}_public_write_rl_' . (int) $post_id . '_' . md5(
+		(string) $resource_key . '|' . {{phpPrefix}}_get_public_write_client_subject()
+	);
+}
+
+function {{phpPrefix}}_get_public_write_request_replay_key( $post_id, $resource_key, $request_id ) {
+	return '{{phpPrefix}}_public_write_req_' . (int) $post_id . '_' . md5(
+		(string) $resource_key . '|' . (string) $request_id
+	);
+}
+
+function {{phpPrefix}}_get_public_write_lock_key( $post_id, $resource_key, $scope, $lock_subject = '' ) {
+	$lock_subject = is_string( $lock_subject ) && '' !== $lock_subject
+		? $lock_subject
+		: {{phpPrefix}}_get_public_write_client_subject();
+
+	return 'wpt_pwl_' . md5(
+		'{{phpPrefix}}|' . (string) $scope . '|' . (int) $post_id . '|' . (string) $resource_key . '|' . $lock_subject
+	);
+}
+
+function {{phpPrefix}}_with_public_write_lock( $post_id, $resource_key, $scope, $callback, $lock_subject = '' ) {
+	global $wpdb;
+
+	$lock_key = {{phpPrefix}}_get_public_write_lock_key( $post_id, $resource_key, $scope, $lock_subject );
+	$acquired = (int) $wpdb->get_var(
+		$wpdb->prepare(
+			'SELECT GET_LOCK(%s, 5)',
+			$lock_key
+		)
+	);
+
+	if ( 1 === $acquired ) {
+		try {
+			return $callback();
+		} finally {
+			$wpdb->get_var(
+				$wpdb->prepare(
+					'SELECT RELEASE_LOCK(%s)',
+					$lock_key
+				)
+			);
+		}
+	}
+
+	return new WP_Error(
+		'rest_temporarily_unavailable',
+		'Could not acquire the public write lock.',
+		array( 'status' => 503 )
+	);
+}
+
+function {{phpPrefix}}_enforce_public_write_rate_limit( $post_id, $resource_key ) {
+	return {{phpPrefix}}_with_public_write_lock(
+		$post_id,
+		$resource_key,
+		'rate_limit',
+		function () use ( $post_id, $resource_key ) {
+			$key   = {{phpPrefix}}_get_public_write_rate_limit_key( $post_id, $resource_key );
+			$count = (int) get_transient( $key );
+
+			if ( $count >= (int) {{phpPrefixUpper}}_PUBLIC_WRITE_RATE_LIMIT_MAX ) {
+				return new WP_Error(
+					'rest_rate_limited',
+					'Too many public write attempts. Wait a minute and try again.',
+					array( 'status' => 429 )
+				);
+			}
+
+			set_transient(
+				$key,
+				$count + 1,
+				(int) {{phpPrefixUpper}}_PUBLIC_WRITE_RATE_LIMIT_WINDOW
+			);
+
+			return true;
+		}
+	);
+}
+
+function {{phpPrefix}}_consume_public_write_request_id( $post_id, $resource_key, $request_id ) {
+	if ( ! is_string( $request_id ) || '' === $request_id ) {
+		return new WP_Error(
+			'rest_forbidden',
+			'The public write request id is missing.',
+			array( 'status' => 403 )
+		);
+	}
+
+	return {{phpPrefix}}_with_public_write_lock(
+		$post_id,
+		$resource_key,
+		'replay',
+		function () use ( $post_id, $resource_key, $request_id ) {
+			$key = {{phpPrefix}}_get_public_write_request_replay_key( $post_id, $resource_key, $request_id );
+			if ( false !== get_transient( $key ) ) {
+				return new WP_Error(
+					'rest_conflict',
+					'This public write request was already processed.',
+					array( 'status' => 409 )
+				);
+			}
+
+			set_transient( $key, 1, (int) {{phpPrefixUpper}}_PUBLIC_WRITE_TTL );
+
+			return true;
+		},
+		$request_id
+	);
+}
+
+function {{phpPrefix}}_release_public_write_request_id( $post_id, $resource_key, $request_id ) {
+	if ( ! is_string( $request_id ) || '' === $request_id ) {
+		return;
+	}
+
+	delete_transient( {{phpPrefix}}_get_public_write_request_replay_key( $post_id, $resource_key, $request_id ) );
+}
+
+// Public write tokens are scaffold-owned by default; customize this flow if you need a different anonymous write policy.
+function {{phpPrefix}}_create_public_write_token( $post_id, $resource_key ) {
+	$expires_at = time() + (int) {{phpPrefixUpper}}_PUBLIC_WRITE_TTL;
+	$payload    = array(
+		'action'      => {{phpPrefix}}_get_public_write_action(),
+		'exp'         => $expires_at,
+		'postId'      => (int) $post_id,
+		'resourceKey' => (string) $resource_key,
+	);
+	$json       = wp_json_encode( $payload );
+
+	if ( ! is_string( $json ) || '' === $json ) {
+		return array(
+			'expiresAt' => $expires_at,
+			'token'     => '',
+		);
+	}
+
+	$payload_segment   = {{phpPrefix}}_base64url_encode( $json );
+	$signature_segment = {{phpPrefix}}_base64url_encode(
+		hash_hmac( 'sha256', $payload_segment, wp_salt( 'nonce' ), true )
+	);
+
+	return array(
+		'expiresAt' => $expires_at,
+		'token'     => $payload_segment . '.' . $signature_segment,
+	);
+}
+
+function {{phpPrefix}}_verify_public_write_token( $token, $post_id, $resource_key ) {
+	if ( ! is_string( $token ) || '' === $token ) {
+		return new WP_Error(
+			'rest_forbidden',
+			'The public write token is missing.',
+			array( 'status' => 403 )
+		);
+	}
+
+	$segments = explode( '.', $token );
+	if ( 2 !== count( $segments ) ) {
+		return new WP_Error(
+			'rest_forbidden',
+			'The public write token format is invalid.',
+			array( 'status' => 403 )
+		);
+	}
+
+	list( $payload_segment, $signature_segment ) = $segments;
+	$expected_signature = {{phpPrefix}}_base64url_encode(
+		hash_hmac( 'sha256', $payload_segment, wp_salt( 'nonce' ), true )
+	);
+
+	if ( ! hash_equals( $expected_signature, $signature_segment ) ) {
+		return new WP_Error(
+			'rest_forbidden',
+			'The public write token signature is invalid.',
+			array( 'status' => 403 )
+		);
+	}
+
+	$payload_json = {{phpPrefix}}_base64url_decode( $payload_segment );
+	if ( false === $payload_json ) {
+		return new WP_Error(
+			'rest_forbidden',
+			'The public write token payload is invalid.',
+			array( 'status' => 403 )
+		);
+	}
+
+	$payload = json_decode( $payload_json, true );
+	if ( ! is_array( $payload ) ) {
+		return new WP_Error(
+			'rest_forbidden',
+			'The public write token payload is invalid.',
+			array( 'status' => 403 )
+		);
+	}
+
+	$expires_at = isset( $payload['exp'] ) ? (int) $payload['exp'] : 0;
+	if ( time() > $expires_at ) {
+		return new WP_Error(
+			'rest_forbidden',
+			'The public write token has expired. Reload the page and try again.',
+			array( 'status' => 403 )
+		);
+	}
+
+	if ( {{phpPrefix}}_get_public_write_action() !== ( isset( $payload['action'] ) ? (string) $payload['action'] : '' ) ) {
+		return new WP_Error(
+			'rest_forbidden',
+			'The public write token action is invalid.',
+			array( 'status' => 403 )
+		);
+	}
+
+	if ( (int) ( isset( $payload['postId'] ) ? $payload['postId'] : 0 ) !== (int) $post_id ) {
+		return new WP_Error(
+			'rest_forbidden',
+			'The public write token is not valid for this post.',
+			array( 'status' => 403 )
+		);
+	}
+
+	if ( (string) ( isset( $payload['resourceKey'] ) ? $payload['resourceKey'] : '' ) !== (string) $resource_key ) {
+		return new WP_Error(
+			'rest_forbidden',
+			'The public write token is not valid for this resource key.',
+			array( 'status' => 403 )
+		);
+	}
+
+	return true;
+}
+
+// Customize the public write gate here when you need different anonymous request checks.
+function {{phpPrefix}}_can_write_publicly( WP_REST_Request $request ) {
+	$payload = $request->get_json_params();
+	if ( ! is_array( $payload ) ) {
+		$payload = array();
+	}
+
+	$post_id      = isset( $payload['postId'] ) ? (int) $payload['postId'] : 0;
+	$resource_key = isset( $payload['resourceKey'] ) ? (string) $payload['resourceKey'] : '';
+	$request_id   = isset( $payload['publicWriteRequestId'] ) ? (string) $payload['publicWriteRequestId'] : '';
+	$token        = isset( $payload['publicWriteToken'] ) ? (string) $payload['publicWriteToken'] : '';
+
+	if ( '' === $token ) {
+		$fallback = $request->get_param( 'publicWriteToken' );
+		$token    = is_string( $fallback ) ? $fallback : '';
+	}
+
+	if ( '' === $request_id ) {
+		$fallback   = $request->get_param( 'publicWriteRequestId' );
+		$request_id = is_string( $fallback ) ? $fallback : '';
+	}
+
+	if ( $post_id <= 0 || '' === $resource_key ) {
+		return new WP_Error(
+			'rest_forbidden',
+			'The public write request is missing its target identifiers.',
+			array( 'status' => 403 )
+		);
+	}
+
+	if ( '' === $request_id ) {
+		return new WP_Error(
+			'rest_forbidden',
+			'The public write request id is missing.',
+			array( 'status' => 403 )
+		);
+	}
+
+	$verification = {{phpPrefix}}_verify_public_write_token( $token, $post_id, $resource_key );
+	if ( is_wp_error( $verification ) ) {
+		return $verification;
+	}
+
+	// Customize this subject or limit strategy if your public write surface needs stronger abuse controls.
+	return {{phpPrefix}}_enforce_public_write_rate_limit( $post_id, $resource_key );
+}

package/templates/_shared/rest-helpers/shared/inc/rest-shared.php.mustache

@@ -0,0 +1,58 @@
+<?php
+
+// Scaffold-owned schema plumbing. Extend request/response behavior in the route handlers instead.
+function {{phpPrefix}}_load_schema_from_build_dir( $build_dir, $schema_name ) {
+	if ( ! is_string( $build_dir ) || '' === $build_dir ) {
+		return null;
+	}
+
+	$path = $build_dir . '/api-schemas/' . $schema_name . '.schema.json';
+	if ( ! is_readable( $path ) ) {
+		return null;
+	}
+
+	$contents = file_get_contents( $path );
+	if ( false === $contents ) {
+		return null;
+	}
+
+	$decoded = json_decode( $contents, true );
+	return is_array( $decoded ) ? $decoded : null;
+}
+
+// Keep schema sanitation aligned with generated JSON Schema unless you are debugging bridge behavior.
+function {{phpPrefix}}_sanitize_rest_schema( $schema ) {
+	if ( ! is_array( $schema ) ) {
+		return $schema;
+	}
+
+	unset( $schema['$schema'], $schema['title'] );
+
+	if ( isset( $schema['properties'] ) && is_array( $schema['properties'] ) ) {
+		foreach ( $schema['properties'] as $key => $property_schema ) {
+			$schema['properties'][ $key ] = {{phpPrefix}}_sanitize_rest_schema( $property_schema );
+		}
+	}
+
+	if ( isset( $schema['items'] ) && is_array( $schema['items'] ) ) {
+		$schema['items'] = {{phpPrefix}}_sanitize_rest_schema( $schema['items'] );
+	}
+
+	return $schema;
+}
+
+// Route handlers call this bridge before product-specific logic runs.
+function {{phpPrefix}}_validate_and_sanitize_request( $value, $build_dir, $schema_name, $param_name ) {
+	$schema = {{phpPrefix}}_load_schema_from_build_dir( $build_dir, $schema_name );
+	if ( ! is_array( $schema ) ) {
+		return new WP_Error( 'missing_schema', 'Missing REST schema.', array( 'status' => 500 ) );
+	}
+
+	$rest_schema = {{phpPrefix}}_sanitize_rest_schema( $schema );
+	$validation  = rest_validate_value_from_schema( $value, $rest_schema, $param_name );
+	if ( is_wp_error( $validation ) ) {
+		return $validation;
+	}
+
+	return rest_sanitize_value_from_schema( $value, $rest_schema, $param_name );
+}

package/templates/_shared/workspace/persistence-auth/inc/rest-auth.php.mustache

@@ -0,0 +1,36 @@
+<?php
+
+function {{phpPrefix}}_get_rest_nonce( WP_REST_Request $request ) {
+	$header_nonce = $request->get_header( 'X-WP-Nonce' );
+	if ( is_string( $header_nonce ) && '' !== $header_nonce ) {
+		return $header_nonce;
+	}
+
+	$query_nonce = $request->get_param( '_wpnonce' );
+	if ( is_string( $query_nonce ) && '' !== $query_nonce ) {
+		return $query_nonce;
+	}
+
+	return null;
+}
+
+function {{phpPrefix}}_can_write_authenticated( WP_REST_Request $request ) {
+	if ( ! is_user_logged_in() ) {
+		return new WP_Error(
+			'rest_forbidden',
+			'Authentication is required to update this block state.',
+			array( 'status' => rest_authorization_required_code() )
+		);
+	}
+
+	$nonce = {{phpPrefix}}_get_rest_nonce( $request );
+	if ( ! is_string( $nonce ) || '' === $nonce || ! wp_verify_nonce( $nonce, 'wp_rest' ) ) {
+		return new WP_Error(
+			'rest_forbidden',
+			'The REST nonce is missing or invalid.',
+			array( 'status' => 403 )
+		);
+	}
+
+	return true;
+}

package/templates/_shared/workspace/persistence-auth/inc/rest-shared.php.mustache

@@ -0,0 +1,55 @@
+<?php
+
+function {{phpPrefix}}_load_schema_from_build_dir( $build_dir, $schema_name ) {
+	if ( ! is_string( $build_dir ) || '' === $build_dir ) {
+		return null;
+	}
+
+	$path = $build_dir . '/api-schemas/' . $schema_name . '.schema.json';
+	if ( ! is_readable( $path ) ) {
+		return null;
+	}
+
+	$contents = file_get_contents( $path );
+	if ( false === $contents ) {
+		return null;
+	}
+
+	$decoded = json_decode( $contents, true );
+	return is_array( $decoded ) ? $decoded : null;
+}
+
+function {{phpPrefix}}_sanitize_rest_schema( $schema ) {
+	if ( ! is_array( $schema ) ) {
+		return $schema;
+	}
+
+	unset( $schema['$schema'], $schema['title'] );
+
+	if ( isset( $schema['properties'] ) && is_array( $schema['properties'] ) ) {
+		foreach ( $schema['properties'] as $key => $property_schema ) {
+			$schema['properties'][ $key ] = {{phpPrefix}}_sanitize_rest_schema( $property_schema );
+		}
+	}
+
+	if ( isset( $schema['items'] ) && is_array( $schema['items'] ) ) {
+		$schema['items'] = {{phpPrefix}}_sanitize_rest_schema( $schema['items'] );
+	}
+
+	return $schema;
+}
+
+function {{phpPrefix}}_validate_and_sanitize_request( $value, $build_dir, $schema_name, $param_name ) {
+	$schema = {{phpPrefix}}_load_schema_from_build_dir( $build_dir, $schema_name );
+	if ( ! is_array( $schema ) ) {
+		return new WP_Error( 'missing_schema', 'Missing REST schema.', array( 'status' => 500 ) );
+	}
+
+	$rest_schema = {{phpPrefix}}_sanitize_rest_schema( $schema );
+	$validation  = rest_validate_value_from_schema( $value, $rest_schema, $param_name );
+	if ( is_wp_error( $validation ) ) {
+		return $validation;
+	}
+
+	return rest_sanitize_value_from_schema( $value, $rest_schema, $param_name );
+}