nested oneToOne relation removed from published version after update
### Node Version

20.18.1

### NPM/Yarn/PNPM Version

yarn v1.22.22

### Strapi Version

5.9.0

### Operating System

Linux (Debian/Ubuntu)

### Database

MySQL

### Javascript or Typescript

Typescript

### Reproduction URL

_No response_

### Bug Description

I have an article schema with legacy data content type nested in oneToOne relation.  I import data with json and create article, then pass the documentId to legacy create; all using document service.  Article has draftAndPublish enabled, legacy does not.  

Viewing in the database, we have two records for published articles as expected, and one entry per legacy data.  Legacy links table also references both article records (draft and published) for published articles.  As such when requesting (via API) a published article, the published or draft versions can have legacy data populated.  

The issue however is that after updating an entirely different relation (related articles) via documents service update (with status published), the legacy link to the published data is gone.  In the article table, the published version was deleted and recreated in the table (expected), but why would the legacy link, maintaining the relation with published data, go away?  It was never even a part of the update data.  Maybe I'm missing something I have to maintain myself in this relation? 

Subsequent API request reveal legacy data is now null on published version and only available in draft version.  At first I thought maybe I have to also enable draftAndPublish for legacy content type but that yielded the same result.  

### Steps to Reproduce

Create a content type in strapi with a nested content type in oneToOne relation; setup the nested content type to reflect oneToOne mapping.

Create the main content type with documents service (status published), then create the nested entry providing the created main type documentId.  

Observe the database records for the main content type, one for each version (draft and published), and the single record for the nested type.  Observe database table links for the single nested type to both draft and published versions.  

Now perform an update on something unrelated in the main content type, using status published, and only providing the data to be updated.  Now observe that the nested type can no longer be populated by the main content type published version.  The database link is also gone.  


### Expected Behavior

I expect the oneToOne relation to remain on both draft and published versions as it was made during create.  I expected when updating unrelated data it should have no impact on other relations.  

### Logs

```shell

```

### Code Snippets

{
  "kind": "collectionType",
  "collectionName": "articles",
  "info": {
    "singularName": "article",
    "pluralName": "articles",
    "displayName": "Article"
  },
  "options": {
    "draftAndPublish": true
  },
  "pluginOptions": {
    "i18n": {
      "localized": true
    }
  },
  "attributes": {
    "title": {
      "type": "string",
      "required": true,
      "pluginOptions": {
        "i18n": {
          "localized": true
        }
      }
    },
    "content": {
      "type": "richtext",
      "required": true,
      "pluginOptions": {
        "i18n": {
          "localized": true
        }
      }
    },
    "type": {
      "type": "string",
      "required": true,
      "pluginOptions": {
        "i18n": {
          "localized": true
        }
      }
    },
    "slug": {
      "type": "uid",
      "targetField": "title",
      "required": true,
      "unique": true,
      "pluginOptions": {
        "i18n": {
          "localized": true
        }
      }
    },
    "excerpt": {
      "type": "text",
      "required": true,
      "pluginOptions": {
        "i18n": {
          "localized": true
        }
      }
    },
    "authors": {
      "type": "relation",
      "relation": "manyToMany",
      "target": "api::author.author",
      "inversedBy": "articles"
    },
    "relatedArticles": {
      "type": "relation",
      "relation": "manyToMany",
      "target": "api::article.article",
      "label": "Related Articles",
      "placeholder": "Add Related Article" 
    },
    "publishedAt": {
      "type": "datetime",
      "required": false
    },
    "firstPublishedAt": {
      "type": "datetime",
      "required": false
    },
    "tags": {
      "type": "relation",
      "relation": "manyToMany",
      "target": "api::tag.tag",
      "inversedBy": "articles"
    },
    "regions": {
      "type": "relation",
      "relation": "manyToMany",
      "target": "api::region.region",
      "inversedBy": "articles"
    },
    "categories": {
      "type": "relation",
      "relation": "manyToMany",
      "target": "api::category.category",
      "inversedBy": "articles"
    },
    "isFeatured": {
      "type": "boolean",
      "default": false
    },
    "featuredVideoUrl": {
      "type": "string",
      "default": ""
    },
    "legacy": {
      "type": "relation",
      "relation": "oneToOne",
      "target": "api::legacy.legacy",
      "mappedBy": "article",
      "visible": false
    },
    "createdBy": {
      "type": "relation",
      "relation": "manyToOne",
      "target": "admin::user",
      "private": true,
      "configurable": false
    }
  }
}



{
  "kind": "collectionType",
  "collectionName": "legacies",
  "info": {
    "singularName": "legacy",
    "pluralName": "legacies",
    "displayName": "Legacy"
  },
  "options": {
    "draftAndPublish": true,
    "populateCreatorFields": false,
    "create": false, 
    "update": false,
    "delete": false
  },
  "pluginOptions": {
    "content-manager": {
      "visible": false
    },
    "content-type-builder": {
      "visible": false
    }
  },
  "attributes": {
    "postId": {
      "type": "integer",
      "required": true,
      "unique": true
    },
    "userId": {
      "type": "integer",
      "required": true
    },
    "postStatus": {
      "type": "string",
      "required": true
    },
    "postDate": {
      "type": "datetime",
      "required": true
    },
    "guid": {
      "type": "string",
      "required": true
    },
    "postModified": {
      "type": "datetime",
      "required": true
    },
    "author": {
      "type": "string",
      "required": true
    },
    "isFeatured": {
      "type": "string",
      "required": true
    },
    "article": {
      "type": "relation",
      "relation": "oneToOne",
      "target": "api::article.article",
      "inversedBy": "legacy"
    }
  }
}

creating an article:


let newArticle;
        let newLegacy;
        try {
            try {
                const articleResponse = await this.strapi.documents('api::article.article').create({
                    data: {
                        ...articleData,
                        slug: slug?.trim() || null,
                    },
                    status: isPublished ? 'published' : 'draft',
                });

                newArticle = articleResponse;

            } catch (error) {
                const isSlugDuplicate = Array.isArray(error.details?.errors) 
                    ? error.details.errors.some(e => e.path?.[0] === 'slug' && e.message === 'This attribute must be unique')
                    : error.message?.includes('unique');

                if (isSlugDuplicate) {
                    console.log(`Duplicate slug found for ${slug}, retrying with postId suffix`);
                    const uniqueSlug = sanitizeSlug(slug || '', legacy.postId);
                    newArticle = await this.strapi.documents('api::article.article').create({
                        data: {
                            ...articleData,
                            slug: uniqueSlug,
                        },
                        status: isPublished ? 'published' : 'draft',
                    });

                } else {
                    throw new Error(`Failed to create article: ${error.message}`);
                }
            }

            if (!newArticle?.documentId) {
                throw new Error('Failed to create article - invalid response from Strapi');
            }

            try {
                // Create legacy entry
                newLegacy = await this.strapi.documents('api::legacy.legacy').create({
                    data: {
                        postId: legacy.postId,
                        userId: legacy.userId,
                        postStatus: legacy.postStatus,
                        postDate: legacy.postDate,
                        guid: legacy.guid,
                        postModified: legacy.postModified,
                        author: legacy.author || "",
                        isFeatured: isFeatured.toString(),
                        article: newArticle.documentId
                    }
                });
            } catch (error) {
                throw new Error(`Failed to create legacy entry: ${error.message}`);
            }


then updating an article at some other point:

const draftArticle = await strapi.documents('api::article.article').findFirst({
                    filters: {
                        legacy: {
                            postId: {
                                $eq: postId
                            }
                        }
                    },
                    status: 'draft'
                });
                
                const publishedArticle = await strapi.documents('api::article.article').findFirst({
                    filters: {
                        legacy: {
                            postId: {
                                $eq: postId
                            }
                        }
                    },
                    status: 'published'
                });
                
                const strapiArticle = {
                    draft: draftArticle,
                    published: publishedArticle,
                    isPublished: !!publishedArticle
                };

                if (!strapiArticle.draft && !strapiArticle.published) {
                    // If no draft or published article found, skip this postId
                    console.warn(`No Strapi article found for WordPress postId: ${postId}`);
                    return;
                }

                // Find Strapi IDs for the related articles
                const relatedStrapiArticles = await strapi.documents('api::article.article').findMany({
                    filters: {
                        legacy: {
                            postId: {
                                $in: relatedArticleIds
                            }
                        }
                    }
                });

                const relatedArticleIdsMapped = relatedStrapiArticles.map((article) => article.documentId);

                const updateData = {
                    relatedArticles: {
                        connect: relatedArticleIdsMapped.map(id => ({ documentId: id }))
                    }
                };

                await strapi.documents('api::article.article').update({
                    documentId: strapiArticle.draft.documentId,
                    data: updateData as any,
                    status: strapiArticle.isPublished ? 'published' : 'draft'
                });

### Media

_No response_

### Additional information

_No response_

### Confirmation Checklist

- [x] I have checked the existing [issues](https://github.com/strapi/strapi/issues) for duplicates.
- [x] I agree to follow this project's [Code of Conduct](https://github.com/strapi/strapi/blob/develop/CODE_OF_CONDUCT.md).