Hi Mats,

Unfortunately there isn't a way to be able to query the currently stored synonyms using the API endpoint, something I feel there should be... so the best way of managing these in my opinion is to set them up in a global site settings page in your site, and then create an initializable module that hooks into the PublishedContent event and calls a SynonymsUpload service if the page being published is of type SiteSettings page.

See example code below:

SynonymsInitializationModule

/// <summary>
/// On publish of the site settings page check for synonyms and updates graph
/// </summary>
[InitializableModule]
[ModuleDependency(typeof(EPiServer.Web.InitializationModule))]
public sealed class SynonymsInitializationModule : IConfigurableModule
{
    private ISynonymsUploadService? _synonymsUploadService;

    private ILogger<SynonymsInitializationModule>? _logger;

    public void Initialize(InitializationEngine context)
    {
        _synonymsUploadService = context.Locate.Advanced.GetInstance<ISynonymsUploadService>() ??
                                 throw new ArgumentNullException(nameof(_synonymsUploadService));

        _logger = context.Locate.Advanced.GetInstance<ILogger<SynonymsInitializationModule>>();

        var events = context.Locate.Advanced.GetInstance<IContentEvents>();
        events.PublishedContent += OnPagePublished;
    }

    public void Uninitialize(InitializationEngine context)
    {
        var events = context.Locate.Advanced.GetInstance<IContentEvents>();
        events.PublishedContent -= OnPagePublished;
    }

    private async void OnPagePublished(object? sender, ContentEventArgs e)
    {
        try
        {
            if (e.Content is not SiteSettingsPage { Synonyms: { Count: > 0 } searchSynonyms })
                return;

            var language = (e.Content as ILocale)?.Language.Name;

            if (_synonymsUploadService != null)
            {
                await _synonymsUploadService.UploadSynonyms(searchSynonyms, language);
            }

        }
        catch (Exception ex)
        {
            _logger?.LogError("Error uploading synonyms: {0}", ex);
        }
    }

    public void ConfigureContainer(ServiceConfigurationContext context)
    {
    }
}

SynonymsUploadService

public sealed class SynonymsUploadService(
    ILogger<SynonymsUploadService> logger,
    HttpClient httpClient,
    IOptions<ContentGraphOptions> options)
    : ISynonymsUploadService
{
    private readonly string? _graphUrl = options.Value.GatewayAddress;

    private readonly string? _authenticationHeader = (options.Value.AppKey + ":" + options.Value.Secret).Base64Encode();

    public async Task UploadSynonyms(IEnumerable<SynonymsBlock> searchSynonyms, string? language) =>
        await UploadSynonyms(searchSynonyms, language, CancellationToken.None);

    public async Task UploadSynonyms(IEnumerable<SynonymsBlock> searchSynonyms, string? language, CancellationToken cancellationToken)
    {
        try
        {
            var request = new HttpRequestMessage(HttpMethod.Put,
                $"{_graphUrl}/resources/synonyms?synonym_slot=one&language_routing={language}");
            request.Headers.Authorization =
                new AuthenticationHeaderValue("Basic", _authenticationHeader);

            var synonyms = GetSynonyms(searchSynonyms);

            request.Content = new StringContent(synonyms, Encoding.UTF8, "text/plain");

            using var response = await httpClient.SendAsync(request, cancellationToken);

            response.EnsureSuccessStatusCode();
        }
        catch (OperationCanceledException ex)
        {
            logger.LogWarning("The operation was canceled: " + ex.Message);
        }
        catch (HttpRequestException ex)
        {
            logger.LogError("HTTP request failed: " + ex.Message);
        }
        catch (Exception ex) when (ex is not OperationCanceledException)
        {
            logger.LogError(ex, "");
        }
    }

    private static string GetSynonyms(IEnumerable<SynonymsBlock> searchSynonyms)
    {
        var synonymList = new StringBuilder();

        foreach (var synonyms in searchSynonyms)
        {
            if (synonyms.Synonyms is not { Count: > 0 })
                continue;

            var synonymsText = string.Join(", ", synonyms.Synonyms);

            synonymList.AppendLine(synonymsText);
        }

        return synonymList.ToString();
    }
}

Following this method, you can use the CMS as the data source for the synonyms and have them easily updated by an editor.

Thanks,

Graham