PluginProbe
ThinkRank AI SEO – AI SEO Plugin for WordPress: Schema, XML Sitemaps, Meta Tags, Search Console & Local SEO / 2.12.0
ThinkRank AI SEO – AI SEO Plugin for WordPress: Schema, XML Sitemaps, Meta Tags, Search Console & Local SEO v2.12.0
2.12.0 2.11.0 2.10.0 2.9.0 2.8.0 2.7.0 2.6.0 2.5.0 2.4.0 2.3.0 2.2.0 2.1.1 2.1.0 2.0.2 2.0.1 2.0.0 1.32.0 1.31.0 1.30.0 1.29.0 1.28.0 1.27.0 1.26.0 1.25.0 trunk All 53 releases
← All changes | includes/seo/class-schema-management-system.php +844 -91 1.31.0 → 2.12.0 View file →
@@ -167,8 +167,20 @@
167 167 'rich_snippets' => ['video', 'video_carousel'],
168 168 'context_types' => ['post', 'page'],
169 169 'priority' => 'medium'
170 170 ],
171 + // Offered by the metabox dropdown and registered in Schema_Factory, but
172 + // absent here — generate_schema_markup() keys off this array, so a
173 + // Review request was silently skipped (#462).
174 + 'Review' => [
175 + 'name' => 'Review',
176 + 'description' => 'Reviews and ratings of a product, service or place',
177 + 'required_properties' => ['itemReviewed', 'reviewRating', 'author'],
178 + 'recommended_properties' => ['reviewBody', 'datePublished', 'publisher'],
179 + 'rich_snippets' => ['review', 'review_snippet'],
180 + 'context_types' => ['post', 'page'],
181 + 'priority' => 'medium'
182 + ],
171 183 'Recipe' => [
172 184 'name' => 'Recipe',
173 185 'description' => 'Cooking recipes and food preparation',
174 186 'required_properties' => ['name', 'image', 'author', 'datePublished', 'description', 'recipeIngredient', 'recipeInstructions'],
@@ -189,13 +201,43 @@
189 201 'WebPage' => [
190 202 'name' => 'WebPage',
191 203 'description' => 'Individual web pages',
192 204 'required_properties' => ['name', 'url'],
205 + // 'post' as well as 'page': the per-page selector reaches this for
206 + // any post type, and a registry limited to 'page' silently produced
207 + // nothing for the rest (#624).
193 208 'recommended_properties' => ['description', 'author', 'datePublished', 'breadcrumb'],
194 209 'rich_snippets' => ['webpage', 'breadcrumb'],
195 - 'context_types' => ['page'],
210 + 'context_types' => ['page', 'post'],
196 211 'priority' => 'medium'
197 212 ],
213 + 'AboutPage' => [
214 + 'name' => 'AboutPage',
215 + 'description' => 'A page describing the organisation or person behind the site',
216 + 'required_properties' => ['name', 'url'],
217 + 'recommended_properties' => ['description', 'author', 'datePublished', 'breadcrumb'],
218 + 'rich_snippets' => ['webpage', 'breadcrumb'],
219 + 'context_types' => ['page', 'post'],
220 + 'priority' => 'medium'
221 + ],
222 + 'ContactPage' => [
223 + 'name' => 'ContactPage',
224 + 'description' => 'A page giving contact details',
225 + 'required_properties' => ['name', 'url'],
226 + 'recommended_properties' => ['description', 'author', 'datePublished', 'breadcrumb'],
227 + 'rich_snippets' => ['webpage', 'breadcrumb'],
228 + 'context_types' => ['page', 'post'],
229 + 'priority' => 'medium'
230 + ],
231 + 'ProfilePage' => [
232 + 'name' => 'ProfilePage',
233 + 'description' => 'A page about a single person or organisation',
234 + 'required_properties' => ['name', 'url'],
235 + 'recommended_properties' => ['description', 'author', 'datePublished', 'breadcrumb'],
236 + 'rich_snippets' => ['webpage', 'breadcrumb'],
237 + 'context_types' => ['page', 'post'],
238 + 'priority' => 'medium'
239 + ],
198 240 'FAQPage' => [
199 241 'name' => 'FAQPage',
200 242 'description' => 'Frequently Asked Questions pages',
201 243 'required_properties' => ['mainEntity'],
@@ -309,8 +351,19 @@
309 351 */
310 352 private ?Schema_Cache_Manager $cache_manager = null;
311 353
312 354 /**
355 + * Whether the foreign-settings listener has been registered this request.
356 + *
357 + * Static because `thinkrank_seo_settings_saved` is a global hook — one
358 + * listener serves every instance. See the constructor for why (#463).
359 + *
360 + * @since 1.16.0
361 + * @var bool
362 + */
363 + private static bool $foreign_settings_listener_registered = false;
364 +
365 + /**
313 366 * Constructor
314 367 *
315 368 * @since 1.0.0
316 369 */
@@ -326,11 +379,117 @@
326 379 $this->initialize_schema_builder();
327 380
328 381 // Initialize Schema Cache Manager for performance optimization
329 382 $this->initialize_cache_manager();
383 +
384 + // LocalBusiness and Organization both read Business Info, which Site
385 + // Identity owns. Without this, editing an address or phone number never
386 + // refreshed the deployed schema (#455).
387 + //
388 + // Registered at most once per request. WordPress keys callbacks by
389 + // object hash, so binding $this here added a fresh listener for every
390 + // instance — and this class is constructed from inside the very callback
391 + // it registers, which doubled the listener count on every settings save
392 + // (#463). The guard is static because the hook itself is global.
393 + if (!self::$foreign_settings_listener_registered) {
394 + self::$foreign_settings_listener_registered = true;
395 + add_action('thinkrank_seo_settings_saved', [$this, 'refresh_schema_for_foreign_settings'], 10, 4);
396 + }
330 397 }
331 398
332 399 /**
400 + * Regenerate schema when another manager saves settings this schema reads.
401 + *
402 + * Site Identity owns the Business Info fields that feed LocalBusiness and
403 + * the Organization address/contactPoint, so a save there has to refresh the
404 + * deployed schema even though no schema setting changed.
405 + *
406 + * @since 2.0.2
407 + *
408 + * @param string $manager_type Settings category that was saved.
409 + * @param array $settings Settings that were written.
410 + * @param string $context_type Context type.
411 + * @param int|null $context_id Context ID.
412 + * @return void
413 + */
414 + public function refresh_schema_for_foreign_settings(
415 + string $manager_type,
416 + array $settings,
417 + string $context_type,
418 + ?int $context_id
419 + ): void {
420 + if ('site_identity' !== $manager_type) {
421 + return;
422 + }
423 +
424 + $business_keys = [
425 + 'business_name', 'business_type', 'business_address', 'business_city',
426 + 'business_state', 'business_postal_code', 'business_country',
427 + 'business_phone', 'business_email', 'business_hours',
428 + 'business_latitude', 'business_longitude', 'business_price_range',
429 + ];
430 +
431 + // Which deployed types a Site Identity key can invalidate. The business
432 + // block feeds LocalBusiness and Organization; alternate_name feeds the
433 + // WebSite node, which had no entry here at all — so editing it left the
434 + // deployed schema showing the previous value until something else
435 + // happened to redeploy (#692).
436 + $refresh_types = [];
437 +
438 + if (!empty(array_intersect_key($settings, array_flip($business_keys)))) {
439 + $refresh_types[] = 'LocalBusiness';
440 + $refresh_types[] = 'Organization';
441 + }
442 +
443 + if (array_key_exists('alternate_name', $settings)) {
444 + $refresh_types[] = 'WebSite';
445 + }
446 +
447 + if (empty($refresh_types)) {
448 + return;
449 + }
450 +
451 + $schema_settings = $this->get_settings($context_type, $context_id);
452 + if (empty($schema_settings['auto_deploy'])) {
453 + return;
454 + }
455 +
456 + // Only refresh types that are actually deployed, so this never adds a
457 + // type the admin did not enable.
458 + $deployed = array_keys((array) $this->get_deployed_schemas($context_type, $context_id));
459 + $affected = array_values(array_intersect($deployed, $refresh_types));
460 +
461 + if (empty($affected)) {
462 + return;
463 + }
464 +
465 + try {
466 + $generation = $this->generate_schema_markup($context_type, $context_id, $affected);
467 +
468 + // Deploy the types that validated, not all-or-nothing. Gating on
469 + // deployment_ready meant one invalid type blocked every valid one
470 + // in the same batch (#470).
471 + $deployable = [];
472 + foreach ($affected as $type) {
473 + if (!empty($generation['generated_schemas'][$type])
474 + && !empty($generation['validation_results'][$type]['is_valid'])
475 + ) {
476 + $deployable[$type] = $generation['generated_schemas'][$type];
477 + }
478 + }
479 +
480 + if (!empty($deployable)) {
481 + $this->deploy_schema_markup($context_type, $context_id, $deployable);
482 + }
483 + } catch (\Exception $e) {
484 + if (defined('WP_DEBUG') && WP_DEBUG) {
485 + // phpcs:ignore WordPress.PHP.DevelopmentFunctions.error_log_error_log
486 + error_log('ThinkRank: Business Info schema refresh failed: ' . $e->getMessage());
487 + }
488 + }
489 + }
490 +
491 + /**
333 492 * Initialize Schema Builder
334 493 *
335 494 * @return void
336 495 */
@@ -356,10 +515,20 @@
356 515 require_once THINKRANK_PLUGIN_DIR . 'includes/seo/class-schema-cache-manager.php';
357 516 }
358 517
359 518 if (class_exists('ThinkRank\\SEO\\Schema_Cache_Manager')) {
360 - // Get cache duration from deployment config
519 + // Honour the stored cache_duration setting. It is exposed in
520 + // get_settings_schema() (min 300 / max 86400), validated, persisted
521 + // and surfaced through both abilities — but the cache manager was
522 + // always built from the hardcoded config value, so the setting had
523 + // no effect (#473). Falls back to the config default.
361 524 $cache_duration = $this->deployment_config['caching']['duration'] ?? 3600;
525 +
526 + $stored = $this->get_settings('site', null)['cache_duration'] ?? null;
527 + if (is_numeric($stored) && (int) $stored > 0) {
528 + $cache_duration = (int) $stored;
529 + }
530 +
362 531 $this->cache_manager = new Schema_Cache_Manager($cache_duration);
363 532 }
364 533 }
365 534
@@ -367,12 +536,19 @@
367 536 * Generate schema markup with comprehensive content analysis integration
368 537 *
369 538 * @since 1.0.0
370 539 *
540 + * Generation is read-only by default. Persisting the result is opt-in via
541 + * `$options['persist']`, because this method is also reached from the
542 + * front-end read path (get_output_data()) and from GET routes — where a
543 + * DELETE + INSERT would destroy the admin's deployed rows and publish
544 + * types nobody deployed (#460).
545 + *
371 546 * @param string $context_type Context type
372 547 * @param int|null $context_id Context ID
373 548 * @param array $schema_types Schema types to generate
374 - * @param array $options Generation options
549 + * @param array $options Generation options. Pass `persist => true`
550 + * from explicit write paths only.
375 551 * @return array Comprehensive schema generation results
376 552 */
377 553 public function generate_schema_markup(string $context_type, ?int $context_id, array $schema_types = [], array $options = []): array {
378 554 $generation = [
@@ -443,10 +619,16 @@
443 619
444 620 // Check deployment readiness
445 621 $generation['deployment_ready'] = $this->check_deployment_readiness($generation['validation_results']);
446 622
447 - // Store schema data
448 - $this->store_schema_data($context_type, $context_id, $generation);
623 + // Persistence belongs to deployment, not generation. Every write path
624 + // (refresh_schema_for_foreign_settings(), auto_deploy_schema_on_settings_change(),
625 + // the deploy route) calls deploy_schema_markup() straight after generating,
626 + // so nothing needs to opt in today — the flag exists to keep this an
627 + // explicit decision rather than an accident.
628 + if (!empty($options['persist'])) {
629 + $this->store_schema_data($context_type, $context_id, $generation);
630 + }
449 631
450 632 return $generation;
451 633 }
452 634
@@ -574,8 +756,24 @@
574 756
575 757 // Determine deployment method
576 758 $deployment['deployment_method'] = $this->determine_deployment_method($options);
577 759
760 + // When the caller owns the whole context — the user pressing Deploy, where
761 + // the payload is exactly what the preview showed — anything not in that
762 + // payload should come off the page (#464). Incremental callers such as
763 + // auto_deploy_schema_on_settings_change() pass only the types they
764 + // regenerated, so they must NOT retire the rest.
765 + if (!empty($options['authoritative'])) {
766 + $deployment['retired_schemas'] = $this->retire_schema_types(
767 + $context_type,
768 + $context_id,
769 + array_diff(
770 + array_keys($this->get_deployed_schemas($context_type, $context_id)),
771 + array_keys($schema_data)
772 + )
773 + );
774 + }
775 +
578 776 // Deploy each schema
579 777 foreach ($schema_data as $schema_type => $schema) {
580 778 $deploy_result = $this->deploy_single_schema($schema, $schema_type, $deployment['deployment_method'], $context_type, $context_id);
581 779 $deployment['deployed_schemas'][$schema_type] = $deploy_result;
@@ -584,21 +782,91 @@
584 782 // Clean up duplicate schemas
585 783 $this->cleanup_duplicate_schemas($context_type, $context_id);
586 784
587 785 // CACHE INVALIDATION: Clear cache after successful deployment
786 + $cache_invalidated = false;
588 787 if ($this->cache_manager && !empty($deployment['deployed_schemas'])) {
589 788 $this->cache_manager->invalidate_context_cache($context_type, $context_id);
789 + $cache_invalidated = true;
590 790 }
591 791
592 - // Set deployment status based on results
593 - $deployment['cache_status'] = ['cache_updated' => true, 'message' => 'Schema cache updated'];
594 - $deployment['validation_post_deployment'] = ['validation_passed' => true, 'message' => 'Schema deployed successfully'];
595 - $deployment['deployment_status'] = !empty($deployment['deployed_schemas']) ? 'success' : 'failed';
792 + $deployment['cache_status'] = $cache_invalidated
793 + ? ['cache_updated' => true, 'message' => 'Schema cache invalidated']
794 + : ['cache_updated' => false, 'message' => 'No schema cache to invalidate'];
596 795
796 + // Post-deployment verification: read back through the same accessor the
797 + // front end uses, so a row that was written but is not retrievable (wrong
798 + // context, inactive, stale cache) is reported as a failure instead of
799 + // being assumed successful.
800 + $deployment['validation_post_deployment'] = $this->verify_deployment(
801 + $context_type,
802 + $context_id,
803 + array_keys($deployment['deployed_schemas'])
804 + );
805 +
806 + $writes_ok = !empty($deployment['deployed_schemas']);
807 + foreach ($deployment['deployed_schemas'] as $deploy_result) {
808 + if (empty($deploy_result['deployed'])) {
809 + $writes_ok = false;
810 + break;
811 + }
812 + }
813 +
814 + $deployment['deployment_status'] =
815 + ($writes_ok && !empty($deployment['validation_post_deployment']['validation_passed']))
816 + ? 'success'
817 + : 'failed';
818 +
597 819 return $deployment;
598 820 }
599 821
600 822 /**
823 + * Verify deployed schema is retrievable after a deploy.
824 + *
825 + * Reads back through get_deployed_schemas() — the same accessor
826 + * Frontend\SEO_Manager::output_site_schema_markup() uses to emit schema — so
827 + * the check reflects what will actually reach the page rather than only that
828 + * an INSERT returned without error.
829 + *
830 + * @since 1.32.0
831 + *
832 + * @param string $context_type Context type
833 + * @param int|null $context_id Context ID
834 + * @param array $expected_types Schema types that were just deployed
835 + * @return array Validation result
836 + */
837 + private function verify_deployment(string $context_type, ?int $context_id, array $expected_types): array {
838 + if (empty($expected_types)) {
839 + return [
840 + 'validation_passed' => false,
841 + 'message' => 'No schema was deployed',
842 + 'missing_types' => []
843 + ];
844 + }
845 +
846 + $retrieved = $this->get_deployed_schemas($context_type, $context_id);
847 + $missing = array_values(array_diff($expected_types, array_keys($retrieved)));
848 +
849 + if (!empty($missing)) {
850 + return [
851 + 'validation_passed' => false,
852 + 'message' => sprintf(
853 + /* translators: %s: comma-separated list of schema types */
854 + __('Deployed schema could not be read back: %s', 'thinkrank'),
855 + implode(', ', $missing)
856 + ),
857 + 'missing_types' => $missing
858 + ];
859 + }
860 +
861 + return [
862 + 'validation_passed' => true,
863 + 'message' => __('Schema deployed and read back from storage', 'thinkrank'),
864 + 'missing_types' => []
865 + ];
866 + }
867 +
868 + /**
601 869 * Track schema performance and rich snippet appearances
602 870 *
603 871 * @since 1.0.0
604 872 *
@@ -713,9 +981,11 @@
713 981 'validation_results' => [],
714 982 'rich_snippets_preview' => [],
715 983 'performance_data' => [],
716 984 'recommendations' => [],
717 - 'enabled' => true
985 + // Report the real setting. Hardcoding true here told every consumer
986 + // the feature was on even when the master switch was off (#461).
987 + 'enabled' => (bool) ($settings['enabled'] ?? true)
718 988 ];
719 989
720 990 // Get enabled schema types
721 991 $enabled_types = $settings['enabled_schema_types'] ?? [];
@@ -969,8 +1239,47 @@
969 1239 return home_url('/wp-content/plugins/thinkrank/assets/images/default-logo.jpg');
970 1240 }
971 1241
972 1242 /**
1243 + * Schema keys outside the shared config defaults.
1244 + *
1245 + * @since 2.0.1
1246 + *
1247 + * @return string[]
1248 + */
1249 + protected function additional_setting_keys(): array {
1250 + return [
1251 + 'enable_article_schema', 'enable_product_schema',
1252 + 'enable_faq_schema', 'enable_howto_schema',
1253 + ];
1254 + }
1255 +
1256 + /**
1257 + * Per-entity schema fields are an open set.
1258 + *
1259 + * Each schema type the UI can edit contributes its own field family —
1260 + * organization_*, person_*, website_*, business_*, software_*, howto_* —
1261 + * and a new type adds another. The families this manager owns are matched
1262 + * rather than enumerated, so adding a form does not silently start
1263 + * dropping its fields (#452).
1264 + *
1265 + * @since 2.0.1
1266 + *
1267 + * @return string[]
1268 + */
1269 + protected function dynamic_setting_key_patterns(): array {
1270 + return [
1271 + '/^organization_[a-z0-9_]+$/',
1272 + '/^person_[a-z0-9_]+$/',
1273 + '/^website_[a-z0-9_]+$/',
1274 + '/^business_[a-z0-9_]+$/',
1275 + '/^software_[a-z0-9_]+$/',
1276 + '/^howto_[a-z0-9_]+$/',
1277 + '/^product_[a-z0-9_]+$/',
1278 + ];
1279 + }
1280 +
1281 + /**
973 1282 * Get default settings for a context type (implements interface)
974 1283 *
975 1284 * @since 1.0.0
976 1285 *
@@ -1062,38 +1371,59 @@
1062 1371 if ($this->has_person_settings_changed($settings)) {
1063 1372 $schema_types_to_regenerate[] = 'Person';
1064 1373 }
1065 1374
1375 + // Honour the user's Schema Types selection. Without this the payload
1376 + // shape alone decided what shipped, so every save deployed all four
1377 + // types — including ones the user had explicitly deselected (#461).
1378 + // An empty selection means "auto", so only filter when one is set.
1379 + $enabled_types = $settings['enabled_schema_types'] ?? $this->get_settings($context_type, $context_id)['enabled_schema_types'] ?? [];
1380 +
1381 + if (!empty($enabled_types) && is_array($enabled_types)) {
1382 + $schema_types_to_regenerate = array_values(
1383 + array_intersect($schema_types_to_regenerate, $enabled_types)
1384 + );
1385 + }
1386 +
1387 + // Types that were deployed but are no longer wanted must come back off
1388 + // the page — deployment used to be additive-only (#464).
1389 + $this->retire_unselected_schema_types($context_type, $context_id, $enabled_types);
1390 +
1066 1391 // If no schema types need regeneration, return early
1067 1392 if (empty($schema_types_to_regenerate)) {
1068 1393 return;
1069 1394 }
1070 1395
1071 - // Generate and deploy each schema type
1072 - foreach ($schema_types_to_regenerate as $schema_type) {
1073 - try {
1074 - // Generate schema using generate_schema_markup
1075 - $generation_result = $this->generate_schema_markup(
1076 - $context_type,
1077 - $context_id,
1078 - [$schema_type]
1079 - );
1396 + // Generate every affected type in ONE call. Generating them one at a
1397 + // time re-entered store_schema_data() per type, and each pass replaced
1398 + // the rows written by the previous one, so only the last type survived
1399 + // (#454). One batch also means one delete and one cache flush.
1400 + try {
1401 + $generation_result = $this->generate_schema_markup(
1402 + $context_type,
1403 + $context_id,
1404 + $schema_types_to_regenerate
1405 + );
1080 1406
1081 - // Deploy if generation was successful
1082 - if (!empty($generation_result['generated_schemas'][$schema_type]) && $generation_result['deployment_ready']) {
1083 - $this->deploy_schema_markup(
1084 - $context_type,
1085 - $context_id,
1086 - [$schema_type => $generation_result['generated_schemas'][$schema_type]]
1087 - );
1407 + $deployable = [];
1408 + foreach ($schema_types_to_regenerate as $schema_type) {
1409 + // Only deploy what validated — see #470.
1410 + if (!empty($generation_result['generated_schemas'][$schema_type])
1411 + && !empty($generation_result['validation_results'][$schema_type]['is_valid'])
1412 + ) {
1413 + $deployable[$schema_type] = $generation_result['generated_schemas'][$schema_type];
1088 1414 }
1089 - } catch (\Exception $e) {
1090 - // Log error but don't fail the settings save
1091 - if ( defined( 'WP_DEBUG' ) && WP_DEBUG ) {
1092 - // phpcs:ignore WordPress.PHP.DevelopmentFunctions.error_log_error_log
1093 - error_log('ThinkRank: Auto-deploy failed for ' . $schema_type . ': ' . $e->getMessage());
1094 - }
1095 1415 }
1416 +
1417 + if (!empty($deployable)) {
1418 + $this->deploy_schema_markup($context_type, $context_id, $deployable);
1419 + }
1420 + } catch (\Exception $e) {
1421 + // Log error but don't fail the settings save
1422 + if ( defined( 'WP_DEBUG' ) && WP_DEBUG ) {
1423 + // phpcs:ignore WordPress.PHP.DevelopmentFunctions.error_log_error_log
1424 + error_log('ThinkRank: Auto-deploy failed for ' . implode(', ', $schema_types_to_regenerate) . ': ' . $e->getMessage());
1425 + }
1096 1426 }
1097 1427 }
1098 1428
1099 1429 /**
@@ -1131,9 +1461,15 @@
1131 1461 * @param array $settings Updated settings
1132 1462 * @return bool True if website settings changed
1133 1463 */
1134 1464 private function has_website_settings_changed(array $settings): bool {
1135 - $website_keys = ['site_name', 'site_description', 'site_url'];
1465 + // These are the keys the Website tab actually stores. It previously
1466 + // looked for site_name/site_description/site_url, which belong to Site
1467 + // Identity and never appear in a schema settings payload — so WebSite
1468 + // schema never auto-deployed no matter what was edited (#455).
1469 + $website_keys = [
1470 + 'website_name', 'website_url', 'website_description', 'website_author',
1471 + ];
1136 1472
1137 1473 foreach ($website_keys as $key) {
1138 1474 if (isset($settings[$key])) {
1139 1475 return true;
@@ -1151,11 +1487,20 @@
1151 1487 * @param array $settings Updated settings
1152 1488 * @return bool True if business settings changed
1153 1489 */
1154 1490 private function has_business_settings_changed(array $settings): bool {
1491 + // Only the keys this manager actually stores. business_name/address/
1492 + // phone/hours live in the site_identity category and never reach a
1493 + // schema settings save, so keying off them meant LocalBusiness never
1494 + // auto-deployed (#455). Edits to those fields refresh LocalBusiness
1495 + // through the Site Identity save path instead — see
1496 + // refresh_schema_for_foreign_settings().
1155 1497 $business_keys = [
1156 - 'business_name', 'business_type', 'business_address', 'business_phone',
1157 - 'business_hours', 'business_price_range'
1498 + 'enable_local_business',
1499 + 'business_price_range',
1500 + 'business_geo_latitude',
1501 + 'business_geo_longitude',
1502 + 'business_opening_hours',
1158 1503 ];
1159 1504
1160 1505 foreach ($business_keys as $key) {
1161 1506 if (isset($settings[$key])) {
@@ -1199,8 +1544,29 @@
1199 1544 $detected_types = [];
1200 1545
1201 1546 switch ($context_type) {
1202 1547 case 'site':
1548 + // The admin's Schema Types selection is the answer to "what
1549 + // does this site need"; detection is only the fallback for an
1550 + // install that has not chosen yet (#456).
1551 + $settings = $this->get_settings($context_type, $context_id);
1552 + $enabled = array_values(array_filter(
1553 + array_map('strval', (array) ($settings['enabled_schema_types'] ?? [])),
1554 + 'strlen'
1555 + ));
1556 +
1557 + // Drop stale names the factory no longer registers rather than
1558 + // handing them to the builder to silently skip.
1559 + $enabled = array_values(array_filter(
1560 + $enabled,
1561 + fn($type) => isset($this->schema_types[$type])
1562 + ));
1563 +
1564 + if (!empty($enabled)) {
1565 + $detected_types = $enabled;
1566 + break;
1567 + }
1568 +
1203 1569 $detected_types = ['Organization'];
1204 1570 // Check if it's a local business
1205 1571 if ($this->is_local_business()) {
1206 1572 $detected_types[] = 'LocalBusiness';
@@ -1263,20 +1629,35 @@
1263 1629 } elseif ($context_id && in_array($context_type, ['post', 'page', 'product'], true)) {
1264 1630 // Post/page/product data
1265 1631 $post = get_post($context_id);
1266 1632 if ($post) {
1633 + // Resolve the featured image's URL to its ID here, where the ID
1634 + // is in hand, so the schema builder does not query for an
1635 + // attachment it was just given (#847). Offered as a hint rather
1636 + // than asserted: `post_thumbnail_url` can swap the URL for one
1637 + // the featured image does not own.
1638 + $thumbnail_url = get_the_post_thumbnail_url($post->ID, 'full');
1639 +
1640 + if ($thumbnail_url) {
1641 + Attachment_Lookup::id_from_url((string) $thumbnail_url, (int) get_post_thumbnail_id($post->ID));
1642 + }
1643 +
1267 1644 $content_data = [
1268 1645 'title' => $post->post_title,
1269 1646 'url' => get_permalink($post->ID),
1270 - 'excerpt' => $post->post_excerpt ?: wp_trim_words($post->post_content, 30),
1647 + 'excerpt' => $post->post_excerpt ?: \ThinkRank\Core\Seo_Text::trim_words($post->post_content, 30),
1271 1648 'content' => $post->post_content,
1272 1649 'author' => [
1273 1650 'name' => get_the_author_meta('display_name', $post->post_author),
1274 1651 'url' => get_author_posts_url($post->post_author)
1275 1652 ],
1276 - 'date' => $post->post_date,
1277 - 'modified' => $post->post_modified,
1278 - 'image' => get_the_post_thumbnail_url($post->ID, 'full'),
1653 + // ISO 8601 with offset. post_date/post_modified are raw
1654 + // MySQL columns in site-local time with no timezone, which
1655 + // Google rejects as "Invalid value in field datePublished"
1656 + // and drops the Article rich result (#465).
1657 + 'date' => get_the_date('c', $post),
1658 + 'modified' => get_the_modified_date('c', $post),
1659 + 'image' => $thumbnail_url,
1279 1660 'focus_keywords' => Focus_Keywords::get($post->ID),
1280 1661 'business_data' => $this->get_business_data_from_local_seo(),
1281 1662 'site_data' => $this->get_site_data_for_schema(),
1282 1663 'social_data' => $this->get_social_data_for_schema()
@@ -1370,10 +1751,16 @@
1370 1751 global $wpdb;
1371 1752
1372 1753 $table_name = $wpdb->prefix . 'thinkrank_seo_schema';
1373 1754
1374 - // First, delete all existing schemas for this context to ensure clean storage
1375 - $this->delete_existing_schemas($context_type, $context_id);
1755 + // Replace only the types in this batch. Clearing the whole context
1756 + // destroyed types the caller never asked about — and callers do
1757 + // regenerate a subset, one type at a time (#454).
1758 + $generated_types = array_keys($generation['generated_schemas'] ?? []);
1759 + if (empty($generated_types)) {
1760 + return false;
1761 + }
1762 + $this->delete_existing_schemas($context_type, $context_id, $generated_types);
1376 1763
1377 1764 foreach ($generation['generated_schemas'] as $schema_type => $schema_data) {
1378 1765 // Prepare schema data with validation status embedded
1379 1766 $schema_data_with_validation = $schema_data;
@@ -1389,9 +1776,13 @@
1389 1776 'context_id' => $context_id,
1390 1777 'schema_type' => $schema_type,
1391 1778 'schema_data' => wp_json_encode($schema_data_with_validation),
1392 1779 'validation_status' => $generation['validation_results'][$schema_type]['is_valid'] ? 'valid' : 'invalid',
1393 - 'is_active' => $generation['deployment_ready'] ? 1 : 0
1780 + // Per-type, not batch-wide. deployment_ready is only true when
1781 + // EVERY type in the batch validated, so one invalid type (a site
1782 + // with no Business Info makes LocalBusiness invalid) deactivated
1783 + // all the valid ones alongside it (#470).
1784 + 'is_active' => !empty($generation['validation_results'][$schema_type]['is_valid']) ? 1 : 0
1394 1785 ];
1395 1786
1396 1787 // Insert new schema (existing ones were already deleted)
1397 1788 // phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery, PluginCheck.Security.DirectDB.UnescapedDBParameter -- Schema insertion requires direct database access
@@ -1659,12 +2050,10 @@
1659 2050
1660 2051 /**
1661 2052 * Get deployed schemas for frontend integration
1662 2053 *
1663 - * PERFORMANCE OPTIMIZED: This method now uses:
1664 - * 1. Schema caching layer (90% reduction in database queries)
1665 - * 2. Window function approach instead of correlated subquery (80-90% query performance improvement)
1666 - * 3. Composite index: idx_context_schema_active
2054 + * Returns the newest active, deployed row of each schema type for the
2055 + * context. Results are cached per context (see Schema_Cache_Manager).
1667 2056 *
1668 2057 * @since 1.0.0
1669 2058 *
1670 2059 * @param string $context_type Context type
@@ -1687,47 +2076,59 @@
1687 2076
1688 2077 // Use existing seo_schema table
1689 2078 $table_name = $wpdb->prefix . 'thinkrank_seo_schema';
1690 2079
1691 - // OPTIMIZED QUERY: Use window function approach to eliminate correlated subquery
1692 - // This leverages the new composite index: idx_context_schema_active (context_type, schema_type, is_active, created_at DESC)
2080 + // The newest row per type used to be picked with ROW_NUMBER() OVER
2081 + // (PARTITION BY schema_type ...). Window functions need MySQL 8.0 /
2082 + // MariaDB 10.2, and WordPress still runs on MySQL 5.7, where that is
2083 + // a syntax error on every page view and no deployed schema is ever
2084 + // output. A row is the newest of its type when no other row of the
2085 + // same context and type outranks it, so NOT EXISTS keeps the
2086 + // greatest-per-group in the database, and schema_data — JSON, and
2087 + // large — is only transferred for the rows that are output.
2088 + //
2089 + // `<=>` is NULL-safe equality: the site context stores context_id
2090 + // as NULL, and `n.context_id = s.context_id` is never true for it.
2091 + // schema_id breaks a same-second tie, which the window function
2092 + // left to chance.
2093 + $args = [$context_type];
1693 2094 if (null === $context_id) {
1694 - // phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery,WordPress.DB.DirectDatabaseQuery.NoCaching, PluginCheck.Security.DirectDB.UnescapedDBParameter -- Schema retrieval requires direct database access
1695 - $sql = sprintf(
1696 - 'SELECT schema_type, schema_data FROM (SELECT schema_type, schema_data, ROW_NUMBER() OVER (PARTITION BY schema_type ORDER BY created_at DESC) as rn FROM %s WHERE context_type = %%s AND context_id IS NULL AND is_active = 1 AND validation_status IN (\'deployed\', \'valid\')) ranked WHERE rn = 1 ORDER BY schema_type',
1697 - $table_name
1698 - );
1699 - // phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching, PluginCheck.Security.DirectDB.UnescapedDBParameter -- Schema retrieval requires direct database access
1700 - $deployed_schemas = $wpdb->get_results(
1701 - $wpdb->prepare(
1702 - // phpcs:ignore WordPress.DB.PreparedSQL.NotPrepared, PluginCheck.Security.DirectDB.UnescapedDBParameter -- SQL is properly prepared with placeholders
1703 - $sql,
1704 - $context_type
1705 - ),
1706 - ARRAY_A
1707 - );
2095 + $context_where = 's.context_id IS NULL';
1708 2096 } else {
1709 - // phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery,WordPress.DB.DirectDatabaseQuery.NoCaching, PluginCheck.Security.DirectDB.UnescapedDBParameter -- Schema retrieval requires direct database access
1710 - $sql = sprintf(
1711 - 'SELECT schema_type, schema_data FROM (SELECT schema_type, schema_data, ROW_NUMBER() OVER (PARTITION BY schema_type ORDER BY created_at DESC) as rn FROM %s WHERE context_type = %%s AND context_id = %%d AND is_active = 1 AND validation_status IN (\'deployed\', \'valid\')) ranked WHERE rn = 1 ORDER BY schema_type',
1712 - $table_name
1713 - );
1714 - // phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching, PluginCheck.Security.DirectDB.UnescapedDBParameter -- Schema retrieval requires direct database access
1715 - $deployed_schemas = $wpdb->get_results(
1716 - $wpdb->prepare(
1717 - // phpcs:ignore WordPress.DB.PreparedSQL.NotPrepared, PluginCheck.Security.DirectDB.UnescapedDBParameter -- SQL is properly prepared with placeholders
1718 - $sql,
1719 - $context_type,
1720 - $context_id
1721 - ),
1722 - ARRAY_A
1723 - );
2097 + $context_where = 's.context_id = %d';
2098 + $args[] = $context_id;
1724 2099 }
1725 2100
1726 - if (empty($deployed_schemas)) {
1727 - return [];
1728 - }
2101 + $sql = sprintf(
2102 + 'SELECT s.schema_type, s.schema_data FROM %1$s s'
2103 + . ' WHERE s.context_type = %%s AND %2$s AND s.is_active = 1 AND s.validation_status IN (\'deployed\', \'valid\')'
2104 + . ' AND NOT EXISTS ('
2105 + . 'SELECT 1 FROM %1$s n'
2106 + . ' WHERE n.context_type = s.context_type AND n.context_id <=> s.context_id AND n.schema_type = s.schema_type'
2107 + . ' AND n.is_active = 1 AND n.validation_status IN (\'deployed\', \'valid\')'
2108 + . ' AND (n.created_at > s.created_at OR (n.created_at = s.created_at AND n.schema_id > s.schema_id))'
2109 + . ')'
2110 + . ' ORDER BY s.schema_type',
2111 + $table_name,
2112 + $context_where
2113 + );
1729 2114
2115 + // phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching, PluginCheck.Security.DirectDB.UnescapedDBParameter -- Schema retrieval requires direct database access
2116 + $deployed_schemas = $wpdb->get_results(
2117 + $wpdb->prepare(
2118 + // phpcs:ignore WordPress.DB.PreparedSQL.NotPrepared, PluginCheck.Security.DirectDB.UnescapedDBParameter -- SQL is properly prepared with placeholders
2119 + $sql,
2120 + ...$args
2121 + ),
2122 + ARRAY_A
2123 + );
2124 +
2125 + // Deliberately no early return on an empty result: it has to reach the
2126 + // cache write below. Most URLs have no deployed schema, so gating the
2127 + // write on a non-empty result made the majority of front-end requests
2128 + // permanent cache misses, re-running the query on every pageview (#392).
2129 + $deployed_schemas = $deployed_schemas ?: [];
2130 +
1730 2131 // Process schemas for return
1731 2132 $processed_schemas = [];
1732 2133 foreach ($deployed_schemas as $deployed_schema) {
1733 2134 $schema_data = json_decode($deployed_schema['schema_data'], true);
@@ -1738,8 +2139,26 @@
1738 2139 if (isset($schema_data['_validation'])) {
1739 2140 unset($schema_data['_validation']);
1740 2141 }
1741 2142
2143 + // Deployed schema is a snapshot, so rows written before #465
2144 + // still carry raw MySQL datetimes. Normalise on read so the
2145 + // fix reaches existing sites without a migration.
2146 + $schema_data = $this->normalize_stored_schema($schema_data);
2147 +
2148 + // The permalink was frozen at deploy time, so schema deployed
2149 + // while a post was a draft advertised "?p=123" as both url and
2150 + // mainEntityOfPage forever — contradicting the node's own @id
2151 + // and the canonical (#470). Resolve it live instead.
2152 + $schema_data = $this->refresh_schema_permalink($schema_data, $context_type, $context_id);
2153 +
2154 + // schema.org types `sameAs`, `url`, `logo` and `image` as URLs,
2155 + // but the form stored whatever was typed, so free text entered
2156 + // in a social-profile field shipped as a sameAs member and made
2157 + // the whole entity invalid (#480). Drop bad values on read, so
2158 + // existing sites stop emitting them without a migration.
2159 + $schema_data = $this->filter_entity_urls($schema_data);
2160 +
1742 2161 $processed_schemas[$schema_type] = [
1743 2162 'data' => $schema_data,
1744 2163 'method' => 'json_ld', // Default method
1745 2164 'type' => $schema_type
@@ -1746,10 +2165,13 @@
1746 2165 ];
1747 2166 }
1748 2167 }
1749 2168
1750 - // CACHE LAYER: Store result in cache for future requests
1751 - if ($this->cache_manager && !empty($processed_schemas)) {
2169 + // CACHE LAYER: Store result in cache for future requests — including
2170 + // an empty one. Cache_Manager::set() wraps the payload in a metadata
2171 + // envelope, so an empty result is still stored as a truthy value and
2172 + // reads back as a hit rather than a miss (#392).
2173 + if ($this->cache_manager) {
1752 2174 $cache_key = $this->cache_manager->generate_deployed_schemas_key($context_type, $context_id);
1753 2175 $this->cache_manager->set($cache_key, $processed_schemas);
1754 2176 }
1755 2177
@@ -1756,8 +2178,233 @@
1756 2178 return $processed_schemas;
1757 2179 }
1758 2180
1759 2181 /**
2182 + * Properties schema.org defines as URLs.
2183 + *
2184 + * @since 2.0.2
2185 + * @var string[]
2186 + */
2187 + private const URL_PROPERTIES = ['sameAs', 'url', 'logo', 'image'];
2188 +
2189 + /**
2190 + * Whether a value is a URL safe to publish in structured data.
2191 + *
2192 + * @since 2.0.2
2193 + *
2194 + * @param mixed $url Candidate value.
2195 + * @return bool
2196 + */
2197 + private function is_publishable_url($url): bool {
2198 + if (!is_string($url) || '' === trim($url)) {
2199 + return false;
2200 + }
2201 +
2202 + if (!filter_var($url, FILTER_VALIDATE_URL)) {
2203 + return false;
2204 + }
2205 +
2206 + $scheme = wp_parse_url($url, PHP_URL_SCHEME);
2207 +
2208 + return in_array(strtolower((string) $scheme), ['http', 'https'], true);
2209 + }
2210 +
2211 + /**
2212 + * Drop values that are not URLs from URL-typed properties.
2213 + *
2214 + * An absent property is valid; one holding free text is not, and it can
2215 + * invalidate the entity around it. Nested objects (`logo` and `image` are
2216 + * frequently ImageObjects) are walked so a bad `url` inside one is caught
2217 + * too. A property left with nothing is removed rather than emitted empty.
2218 + *
2219 + * @since 2.0.2
2220 + *
2221 + * @param array $schema Decoded schema data.
2222 + * @return array Schema carrying only publishable URLs.
2223 + */
2224 + private function filter_entity_urls(array $schema): array {
2225 + foreach ($schema as $key => $value) {
2226 + if (is_array($value) && !in_array($key, self::URL_PROPERTIES, true)) {
2227 + $schema[$key] = $this->filter_entity_urls($value);
2228 + continue;
2229 + }
2230 +
2231 + if (!in_array($key, self::URL_PROPERTIES, true)) {
2232 + continue;
2233 + }
2234 +
2235 + // A nested object (ImageObject and friends) carries its own url.
2236 + if (is_array($value) && isset($value['@type'])) {
2237 + $schema[$key] = $this->filter_entity_urls($value);
2238 + continue;
2239 + }
2240 +
2241 + if (is_array($value)) {
2242 + $kept = [];
2243 +
2244 + foreach ($value as $item) {
2245 + if (is_array($item)) {
2246 + $kept[] = $this->filter_entity_urls($item);
2247 + } elseif ($this->is_publishable_url($item)) {
2248 + $kept[] = $item;
2249 + }
2250 + }
2251 +
2252 + if ([] === $kept) {
2253 + unset($schema[$key]);
2254 + } else {
2255 + $schema[$key] = array_values($kept);
2256 + }
2257 +
2258 + continue;
2259 + }
2260 +
2261 + if (!$this->is_publishable_url($value)) {
2262 + unset($schema[$key]);
2263 + }
2264 + }
2265 +
2266 + return $schema;
2267 + }
2268 +
2269 + /**
2270 + * Schema types whose `url` identifies the entity, not the page.
2271 + *
2272 + * On a Person or an Organization, `url` is that entity's own website, so
2273 + * overwriting it with the permalink of whichever post the schema happens to
2274 + * be deployed on is simply wrong. It also breaks graph assembly: the site
2275 + * identity emits the same entity with its real `url`, and once the two
2276 + * copies disagree they can no longer be recognised as one entity (#479).
2277 + *
2278 + * @since 2.0.2
2279 + * @var string[]
2280 + */
2281 + private const ENTITY_URL_TYPES = ['Person', 'Organization', 'LocalBusiness'];
2282 +
2283 + /**
2284 + * Replace a stored permalink snapshot with the post's live permalink.
2285 + *
2286 + * Only touches `url` and `mainEntityOfPage`, and only for post-like
2287 + * contexts where a permalink actually exists. Identity entities are
2288 + * exempt from the `url` rewrite — see self::ENTITY_URL_TYPES.
2289 + *
2290 + * @since 1.16.0
2291 + *
2292 + * @param array $schema Decoded schema data.
2293 + * @param string $context_type Context type.
2294 + * @param int|null $context_id Context ID.
2295 + * @return array Schema with a current permalink.
2296 + */
2297 + private function refresh_schema_permalink(array $schema, string $context_type, ?int $context_id): array {
2298 + if ('site' === $context_type || empty($context_id)) {
2299 + return $schema;
2300 + }
2301 +
2302 + $permalink = get_permalink($context_id);
2303 +
2304 + if (!$permalink) {
2305 + return $schema;
2306 + }
2307 +
2308 + $type = $schema['@type'] ?? '';
2309 + $type = is_array($type) ? reset($type) : $type;
2310 + // A LocalBusiness is deployed under the subtype the site chose, so the
2311 + // exemption has to cover every subtype, not only the literal root.
2312 + $is_entity = in_array((string) $type, self::ENTITY_URL_TYPES, true)
2313 + || \ThinkRank\Config\Local_Business_Types_Config::is_local_business($type);
2314 +
2315 + if (isset($schema['url']) && !$is_entity) {
2316 + $schema['url'] = $permalink;
2317 + }
2318 +
2319 + if (isset($schema['mainEntityOfPage'])) {
2320 + if (is_array($schema['mainEntityOfPage'])) {
2321 + if (isset($schema['mainEntityOfPage']['@id'])) {
2322 + $schema['mainEntityOfPage']['@id'] = $permalink;
2323 + }
2324 + } else {
2325 + $schema['mainEntityOfPage'] = $permalink;
2326 + }
2327 + }
2328 +
2329 + return $schema;
2330 + }
2331 +
2332 + /**
2333 + * Normalise properties that stored snapshots may hold in a stale format.
2334 + *
2335 + * Deployed schema is written once and read forever, so a formatting fix in
2336 + * the builder never reaches rows already on disk. Correcting on read means
2337 + * existing sites benefit without a migration.
2338 + *
2339 + * Covers non-ISO-8601 dates (#465) and WP locales in inLanguage, which must
2340 + * be a BCP-47 tag — en-US, not en_US (#473). Walks nested nodes so values
2341 + * inside author/publisher/@graph entries are covered too.
2342 + *
2343 + * Also decodes HTML entities in plain-text properties. Schema_Builder
2344 + * stored the block editor's `&amp;` as-is until 2.10.0, and nothing
2345 + * decodes JSON-LD downstream, so every deployed node built from post text
2346 + * published the entity literally.
2347 + *
2348 + * @since 1.16.0
2349 + * @since 2.10.0 Decodes entities in plain-text properties.
2350 + *
2351 + * @param array $schema Decoded schema data.
2352 + * @return array Normalised schema.
2353 + */
2354 + private function normalize_stored_schema(array $schema): array {
2355 + static $date_keys = [
2356 + 'datePublished', 'dateModified', 'dateCreated', 'uploadDate',
2357 + 'startDate', 'endDate', 'validFrom', 'validThrough', 'expires',
2358 + ];
2359 +
2360 + // Plain text in schema.org. Answer/HowToStep `text` is deliberately
2361 + // absent: Google reads Answer.text as HTML, where an entity is correct
2362 + // and decoding `&lt;` would turn escaped text into live markup.
2363 + static $text_keys = [
2364 + 'name', 'headline', 'alternativeHeadline', 'description',
2365 + 'reviewBody', 'about', 'abstract', 'caption',
2366 + ];
2367 +
2368 + foreach ($schema as $key => $value) {
2369 + if (is_array($value)) {
2370 + $schema[$key] = $this->normalize_stored_schema($value);
2371 + continue;
2372 + }
2373 +
2374 + if ('inLanguage' === $key && is_string($value) && '' !== $value) {
2375 + $schema[$key] = str_replace('_', '-', $value);
2376 + continue;
2377 + }
2378 +
2379 + // Decode only: a snapshot already truncated with an ellipsis must
2380 + // keep it, which the full Seo_Text::normalize_schema_text() would
2381 + // strip as an excerpt marker.
2382 + if (in_array($key, $text_keys, true) && is_string($value) && '' !== $value) {
2383 + $schema[$key] = \ThinkRank\Core\Seo_Text::decode_schema_entities($value);
2384 + continue;
2385 + }
2386 +
2387 + if (!in_array($key, $date_keys, true) || !is_string($value) || '' === $value) {
2388 + continue;
2389 + }
2390 +
2391 + // Already ISO 8601 — leave it alone.
2392 + if (preg_match('/^\d{4}-\d{2}-\d{2}T/', $value)) {
2393 + continue;
2394 + }
2395 +
2396 + $timestamp = strtotime($value);
2397 +
2398 + if (false !== $timestamp) {
2399 + $schema[$key] = (string) wp_date('c', $timestamp);
2400 + }
2401 + }
2402 +
2403 + return $schema;
2404 + }
2405 +
2406 + /**
1760 2407 * Clean up duplicate schemas in database
1761 2408 *
1762 2409 * @since 1.0.0
1763 2410 *
@@ -1809,28 +2456,131 @@
1809 2456 }
1810 2457
1811 2458 return $deleted ?: 0;
1812 2459 }
2460 +
1813 2461 /**
1814 - * Delete all existing schemas for a context before storing new ones
2462 + * Deactivate deployed schema rows for the given types.
1815 2463 *
2464 + * Deployment was insert-only, so anything ever deployed to a context stayed
2465 + * on the page forever — switching a post's schema type left the old one live
2466 + * and deactivating a saved schema did nothing (#464). Rows are deactivated
2467 + * rather than deleted so a later redeploy can revive them and so there is a
2468 + * trail of what was published.
2469 + *
2470 + * @since 1.16.0
2471 + *
2472 + * @param string $context_type Context type.
2473 + * @param int|null $context_id Context ID.
2474 + * @param string[] $schema_types Types to retire.
2475 + * @return int Number of rows deactivated.
2476 + */
2477 + private function retire_schema_types(string $context_type, ?int $context_id, array $schema_types): int {
2478 + $schema_types = array_values(array_filter(array_map('strval', $schema_types), 'strlen'));
2479 +
2480 + if (empty($schema_types)) {
2481 + return 0;
2482 + }
2483 +
2484 + global $wpdb;
2485 +
2486 + $table_name = $wpdb->prefix . 'thinkrank_seo_schema';
2487 + $placeholders = implode(', ', array_fill(0, count($schema_types), '%s'));
2488 +
2489 + if (null === $context_id) {
2490 + $sql = sprintf(
2491 + 'UPDATE %s SET is_active = 0 WHERE context_type = %%s AND context_id IS NULL AND schema_type IN (%s)',
2492 + $table_name,
2493 + $placeholders
2494 + );
2495 + $args = array_merge([$context_type], $schema_types);
2496 + } else {
2497 + $sql = sprintf(
2498 + 'UPDATE %s SET is_active = 0 WHERE context_type = %%s AND context_id = %%d AND schema_type IN (%s)',
2499 + $table_name,
2500 + $placeholders
2501 + );
2502 + $args = array_merge([$context_type, $context_id], $schema_types);
2503 + }
2504 +
2505 + // phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching, PluginCheck.Security.DirectDB.UnescapedDBParameter -- Retiring deployed schema rows requires direct database access.
2506 + $updated = $wpdb->query(
2507 + $wpdb->prepare(
2508 + // phpcs:ignore WordPress.DB.PreparedSQL.NotPrepared, PluginCheck.Security.DirectDB.UnescapedDBParameter -- SQL is built from an internal table name and generated placeholders.
2509 + $sql,
2510 + $args
2511 + )
2512 + );
2513 +
2514 + if ($updated && $this->cache_manager) {
2515 + $this->cache_manager->invalidate_context_cache($context_type, $context_id);
2516 + }
2517 +
2518 + return (int) ($updated ?: 0);
2519 + }
2520 +
2521 + /**
2522 + * Retire deployed types that are no longer in the user's Schema Types selection.
2523 + *
2524 + * An empty selection means "auto-detect", so nothing is retired in that case.
2525 + *
2526 + * @since 1.16.0
2527 + *
2528 + * @param string $context_type Context type.
2529 + * @param int|null $context_id Context ID.
2530 + * @param array $enabled_types The user's selected types.
2531 + * @return int Number of rows deactivated.
2532 + */
2533 + private function retire_unselected_schema_types(string $context_type, ?int $context_id, array $enabled_types): int {
2534 + if (empty($enabled_types)) {
2535 + return 0;
2536 + }
2537 +
2538 + $deployed = array_keys($this->get_deployed_schemas($context_type, $context_id));
2539 + $stale = array_diff($deployed, $enabled_types);
2540 +
2541 + return $this->retire_schema_types($context_type, $context_id, $stale);
2542 + }
2543 +
2544 + /**
2545 + * Delete stored schemas for a context before storing new ones.
2546 + *
2547 + * `$schema_types` scopes the delete to the types actually being rewritten.
2548 + * Without it this wiped every type in the context, which silently destroyed
2549 + * deployed schema whenever a caller regenerated a subset — and
2550 + * auto_deploy_schema_on_settings_change() regenerates one type at a time
2551 + * (#454). Passing an empty array keeps the original clear-the-context
2552 + * behaviour for callers that genuinely rewrite everything.
2553 + *
1816 2554 * @since 1.0.0
1817 2555 *
1818 2556 * @param string $context_type Context type
1819 2557 * @param int|null $context_id Context ID
2558 + * @param string[] $schema_types Optional. Limit the delete to these types.
1820 2559 * @return int Number of schemas deleted
1821 2560 */
1822 - private function delete_existing_schemas(string $context_type, ?int $context_id): int {
2561 + private function delete_existing_schemas(string $context_type, ?int $context_id, array $schema_types = []): int {
1823 2562 global $wpdb;
1824 2563
1825 2564 $table_name = $wpdb->prefix . 'thinkrank_seo_schema';
1826 2565
2566 + // Build an optional `AND schema_type IN (…)` clause with one prepared
2567 + // placeholder per type, so the scoping cannot be injected through.
2568 + $type_clause = '';
2569 + $type_values = [];
2570 + $schema_types = array_values(array_filter(array_map('strval', $schema_types), 'strlen'));
2571 + if (!empty($schema_types)) {
2572 + $type_clause = ' AND schema_type IN (' . implode(', ', array_fill(0, count($schema_types), '%s')) . ')';
2573 + $type_values = $schema_types;
2574 + }
2575 +
1827 2576 if (null === $context_id) {
1828 2577 // Delete all schemas for NULL context_id
1829 2578 // phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery, PluginCheck.Security.DirectDB.UnescapedDBParameter -- Schema deletion requires direct database access
1830 2579 $sql = sprintf(
1831 - 'DELETE FROM %s WHERE context_type = %%s AND context_id IS NULL',
1832 - $table_name
2580 + 'DELETE FROM %s WHERE context_type = %%s AND context_id IS NULL%s',
2581 + $table_name,
2582 + $type_clause
1833 2583 );
1834 2584 // phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching, PluginCheck.Security.DirectDB.UnescapedDBParameter -- Schema deletion requires direct database access
1835 2585 $deleted = $wpdb->query(
1836 2586 $wpdb->prepare(
@@ -1835,9 +2585,9 @@
1835 2585 $deleted = $wpdb->query(
1836 2586 $wpdb->prepare(
1837 2587 // phpcs:ignore WordPress.DB.PreparedSQL.NotPrepared, PluginCheck.Security.DirectDB.UnescapedDBParameter -- SQL is properly prepared with placeholders
1838 2588 $sql,
1839 - $context_type
2589 + array_merge([$context_type], $type_values)
1840 2590 )
1841 2591 );
1842 2592 } else {
1843 2593 // Delete all schemas for specific context_id
@@ -1842,10 +2592,11 @@
1842 2592 } else {
1843 2593 // Delete all schemas for specific context_id
1844 2594 // phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery, PluginCheck.Security.DirectDB.UnescapedDBParameter -- Schema deletion requires direct database access
1845 2595 $sql = sprintf(
1846 - 'DELETE FROM %s WHERE context_type = %%s AND context_id = %%d',
1847 - $table_name
2596 + 'DELETE FROM %s WHERE context_type = %%s AND context_id = %%d%s',
2597 + $table_name,
2598 + $type_clause
1848 2599 );
1849 2600 // phpcs:ignore WordPress.DB.DirectDatabaseQuery.DirectQuery, WordPress.DB.DirectDatabaseQuery.NoCaching, PluginCheck.Security.DirectDB.UnescapedDBParameter -- Schema deletion requires direct database access
1850 2601 $deleted = $wpdb->query(
1851 2602 $wpdb->prepare(
@@ -1850,10 +2601,9 @@
1850 2601 $deleted = $wpdb->query(
1851 2602 $wpdb->prepare(
1852 2603 // phpcs:ignore WordPress.DB.PreparedSQL.NotPrepared, PluginCheck.Security.DirectDB.UnescapedDBParameter -- SQL is properly prepared with placeholders
1853 2604 $sql,
1854 - $context_type,
1855 - $context_id
2605 + array_merge([$context_type, $context_id], $type_values)
1856 2606 )
1857 2607 );
1858 2608 }
1859 2609
@@ -1937,8 +2687,11 @@
1937 2687 'site_url' => home_url(),
1938 2688 'admin_email' => get_option('admin_email'),
1939 2689 'language' => get_locale(),
1940 2690 'timezone' => get_option('timezone_string'),
2691 + // Read by populate_website_schema(), so the deployed WebSite node
2692 + // carries the same alternateName as the default one (#692).
2693 + 'alternate_name' => $site_identity_settings['alternate_name'] ?? '',
1941 2694 'founded_date' => $site_identity_settings['founded_date'] ?? '',
1942 2695 'founder_name' => $site_identity_settings['founder_name'] ?? '',
1943 2696 'company_type' => $site_identity_settings['company_type'] ?? 'Organization',
1944 2697 // Site Identity assets