<?php
|
namespace JVBase\managers\SEO\schemas\resolvers;
|
|
use JVBase\managers\SEO\schemas\SchemaDefinition;
|
use JVBase\managers\SEO\schemas\SchemaResolverInterface;
|
use JVBase\managers\SEO\SchemaBuilder;
|
use JVBase\managers\SEO\SchemaFieldHelpers;
|
use JVBase\managers\SEO\TemplateResolver;
|
use JVBase\meta\Meta;
|
|
if (!defined('ABSPATH')) {
|
exit;
|
}
|
|
/**
|
* Default schema resolver - handles generic field resolution.
|
*
|
* Type-specific resolvers extend this and override:
|
* - getAutoFields() for auto-enrichment
|
* - resolveField() for custom field handling
|
* - transformField() for custom transformations
|
*
|
* Single transformation pass (fixes the double-transform bug).
|
*/
|
class BaseResolver implements SchemaResolverInterface
|
{
|
protected ?TemplateResolver $templateResolver = null;
|
protected ?SchemaBuilder $builder = null;
|
|
/**
|
* Properties that multi-property transformers expand into
|
* (e.g., location_complex returns both 'address' and 'geo')
|
*/
|
private const MULTI_PROPS = ['address', 'geo', 'openingHours', 'sameAs'];
|
|
public function resolve(SchemaDefinition $definition, ?Meta $meta = null): ?array
|
{
|
$schema = ['@type' => $definition->schemaType];
|
|
if ($definition->id) {
|
$schema['@id'] = $definition->id;
|
}
|
|
$this->builder = SchemaBuilder::getInstance();
|
$this->templateResolver = $this->buildTemplateResolver($definition);
|
|
// Resolve each config field (single pass)
|
foreach ($definition->config as $fieldName => $value) {
|
if ($fieldName === 'type' || $this->isEmpty($value)) {
|
continue;
|
}
|
|
$resolved = $this->resolveField($fieldName, $value, $meta);
|
|
if (!$this->isEmpty($resolved)) {
|
$schema = $this->mergeField($schema, $fieldName, $resolved);
|
}
|
}
|
|
// Auto-enrich with type-specific fields (won't override existing)
|
foreach ($this->getAutoFields($definition) as $fieldName => $value) {
|
if (!isset($schema[$fieldName]) && !$this->isEmpty($value)) {
|
$schema[$fieldName] = $value;
|
}
|
}
|
|
return count($schema) > 1 ? $schema : null;
|
}
|
|
/**
|
* Override in subclasses to add type-specific auto-fields.
|
*/
|
public function getAutoFields(SchemaDefinition $definition): array
|
{
|
return [];
|
}
|
|
/**
|
* Resolve a single field value.
|
*
|
* Template resolution → transformation in one pass.
|
* Subclasses can override for specific field handling.
|
*/
|
protected function resolveField(string $fieldName, mixed $value, ?Meta $meta): mixed
|
{
|
// Resolve template patterns ({{post_title}}, etc.)
|
$value = $this->resolveTemplates($value);
|
|
if ($value === null) {
|
return null;
|
}
|
|
// Single transformation pass
|
return $this->transformField($fieldName, $value, $meta);
|
}
|
|
/**
|
* Resolve template patterns in a value (string or nested array).
|
*
|
* @return mixed Resolved value, or null if unresolvable pattern
|
*/
|
protected function resolveTemplates(mixed $value): mixed
|
{
|
if (is_string($value) && SchemaFieldHelpers::isPattern($value)) {
|
$resolved = $this->templateResolver?->resolve($value);
|
|
// Unresolved pattern → skip
|
if ($resolved === null || SchemaFieldHelpers::isPattern($resolved)) {
|
return null;
|
}
|
|
return $resolved !== '' ? $resolved : null;
|
}
|
|
// Recurse into arrays
|
if (is_array($value)) {
|
$resolved = [];
|
foreach ($value as $key => $subValue) {
|
$sub = $this->resolveTemplates($subValue);
|
if ($sub !== null) {
|
$resolved[$key] = $sub;
|
}
|
}
|
return !empty($resolved) ? $resolved : null;
|
}
|
|
return $value;
|
}
|
|
/**
|
* Transform a field value using its registered transformer.
|
*
|
* This is the SINGLE transformation pass (fixes the old double-transform bug
|
* where autoResolve ran first, then the transformer ran again).
|
*
|
* Override in subclasses to handle specific fields differently.
|
*/
|
protected function transformField(string $fieldName, mixed $value, ?Meta $meta): mixed
|
{
|
// Already transformed (has @type) → return as-is
|
if (is_array($value) && isset($value['@type'])) {
|
return $value;
|
}
|
|
// Get transformer from field definition
|
$fieldDef = $this->builder?->getFieldDefinition($fieldName);
|
|
if ($fieldDef && !empty($fieldDef['transformer'])) {
|
return $this->applyTransformer($value, $fieldDef['transformer'], $fieldName);
|
}
|
|
// Fall back to auto-resolve for fields without explicit transformers
|
return SchemaFieldHelpers::autoResolve($fieldName, $value, $meta);
|
}
|
|
/**
|
* Apply a named transformer from SchemaFieldHelpers.
|
*/
|
protected function applyTransformer(mixed $value, string $transformer, string $fieldName): mixed
|
{
|
if (!method_exists(SchemaFieldHelpers::class, $transformer)) {
|
return $value;
|
}
|
|
try {
|
return SchemaFieldHelpers::$transformer($value);
|
} catch (\Throwable $e) {
|
error_log("Schema transformer error for {$fieldName}: {$e->getMessage()}");
|
return $value;
|
}
|
}
|
|
/**
|
* Merge a resolved field into the schema array.
|
*
|
* Handles multi-property returns (e.g., location_complex → address + geo).
|
*/
|
protected function mergeField(array $schema, string $fieldName, mixed $value): array
|
{
|
// Check for multi-property expansion
|
if (is_array($value) && !isset($value['@type']) && !isset($value[0])) {
|
if (!empty(array_intersect(array_keys($value), self::MULTI_PROPS))) {
|
foreach ($value as $subKey => $subValue) {
|
if (!$this->isEmpty($subValue)) {
|
$schema[$subKey] = $subValue;
|
}
|
}
|
return $schema;
|
}
|
}
|
|
$schema[$fieldName] = $value;
|
return $schema;
|
}
|
|
/**
|
* Build the TemplateResolver for this definition's context.
|
*/
|
protected function buildTemplateResolver(SchemaDefinition $definition): ?TemplateResolver
|
{
|
if ($definition->objectId && $definition->objectType) {
|
return new TemplateResolver(
|
$definition->objectId,
|
$definition->objectType,
|
$definition->contentType
|
);
|
}
|
|
return TemplateResolver::forCurrentObject();
|
}
|
|
/**
|
* Build a Meta instance for the definition's context.
|
*/
|
protected function buildMeta(SchemaDefinition $definition): ?Meta
|
{
|
if (!$definition->objectId || !$definition->objectType) {
|
return null;
|
}
|
|
return new Meta($definition->objectId, $definition->objectType);
|
}
|
|
protected function isEmpty(mixed $value): bool
|
{
|
return $value === null || $value === '' || $value === [];
|
}
|
}
|
