feat: add Crossref DOI provider

* include more flexible datacite doi prefix use similar to crossref

Author: mfenner

invenio_rdm_records/config.py

@@ -30,7 +30,7 @@
 from . import tokens
 from .requests.community_inclusion import CommunityInclusion
 from .requests.community_submission import CommunitySubmission
-from .resources.serializers import CrossrefXMLSerializer, DataCite45JSONSerializer
+from .resources.serializers import DataCite45JSONSerializer
 from .services import facets
 from .services.config import lock_edit_published_files
 from .services.permissions import RDMRecordPermissionPolicy
@@ -536,14 +536,15 @@ def always_valid(identifier):
 """
 
 RDM_PERSISTENT_IDENTIFIERS = {
-    # DOI automatically removed if DATACITE_ENABLED is False.
+    # DOI automatically removed if DATACITE_ENABLED and CROSSREF_ENABLED are False.
     "doi": {
-        "providers": ["datacite", "external"],
+        "providers": ["datacite", "crossref", "external"],
         "required": True,
         "label": _("DOI"),
         "validator": idutils.is_doi,
         "normalizer": idutils.normalize_doi,
-        "is_enabled": providers.DataCitePIDProvider.is_enabled,
+        "is_enabled": providers.DataCitePIDProvider.is_enabled
+        or providers.CrossrefPIDProvider.is_enabled,
         "ui": {"default_selected": "yes"},  # "yes", "no" or "not_needed"
     },
     "oai": {
@@ -612,6 +613,9 @@ def always_valid(identifier):
 DATACITE_PREFIX = ""
 """DataCite DOI prefix."""
 
+DATACITE_ADDITIONAL_PREFIXES = []
+"""List of additional DataCite DOI prefixes supported for registration."""
+
 DATACITE_TEST_MODE = True
 """DataCite test mode enabled."""
 
@@ -651,6 +655,9 @@ def make_doi(prefix, record):
 CROSSREF_PREFIX = ""
 """Crossref DOI prefix."""
 
+CROSSREF_ADDITIONAL_PREFIXES = []
+"""List of additional Crossref DOI prefixes supported for registration."""
+
 CROSSREF_DEPOSITOR = ""
 """Crossref depositor name."""
 

invenio_rdm_records/resources/serializers/crossref/__init__.py

@@ -12,6 +12,7 @@
     CrossrefError,
     CrossrefXMLSchema,
     Metadata,
+    tostring,
     write_crossref_xml,
 )
 from flask import current_app
@@ -24,39 +25,86 @@ class CrossrefXMLSerializer(MarshmallowSerializer):
 
     def __init__(self, **options):
         """Constructor."""
+        encoder = options.get("encoder", tostring)
         super().__init__(
             format_serializer_cls=SimpleSerializer,
             object_schema_cls=CrossrefXMLSchema,
             list_schema_cls=BaseListSchema,
-            encoder=self.crossref_xml_tostring,
+            encoder=encoder,
             **options,
         )
 
-    def dump_obj(self, record):
+    def serialize_object(self, obj):
+        """Serialize a single record to Crossref XML bytes.
+
+        Overrides the default to avoid double-encoding, since
+        ``dump_obj`` already returns XML bytes.
+        """
+        return self.dump_obj(obj)
+
+    def dump_obj(self, record, url=None):
         """Dump a single record.
 
-        Uses config variables for Crossref XML head elements.
+        Config variables for Crossref XML head elements are used in the
+        XML head element.
 
-        :param record: Record instance.
+        :param record: Record instance (dict, Record model, or ChainObject).
+        :param url: the landing page URL for the DOI.
+            Falls back to ``SITE_UI_URL``/records/<id> if not provided.
         """
+        # Determine the URL that the DOI resolves to, in the following order:
+        #
+        # 1. identifier of type url in ``metadata.identifiers``
+        #    (e.g. archived original content)
+        # 2. The landing page URL passed by the PID service
+        # 3. Default constructed from ``SITE_UI_URL`` and record ID
+        #    (e.g. for Celery tasks or tests without UI endpoints)
+        identifiers = (
+            record.get("metadata", {}).get("identifiers", [])
+            if isinstance(record, dict)
+            else getattr(getattr(record, "metadata", None), "get", lambda *a: [])(
+                "identifiers", []
+            )
+        )
+        registered_url = (
+            next(
+                (
+                    i.get("identifier")
+                    for i in (identifiers or [])
+                    if i.get("scheme") == "url" and i.get("identifier") is not None
+                ),
+                None,
+            )
+            or url
+        )
+
+        if registered_url is None:
+            site_url = current_app.config.get("SITE_UI_URL", "")
+            record_id = (
+                record.get("id")
+                if isinstance(record, dict)
+                else getattr(record, "id", None)
+            )
+            if site_url and record_id:
+                registered_url = f"{site_url}/records/{record_id}"
+
         # Convert the metadata to crossref_xml format via the commonmeta intermediary format.
         # XML Schema validation errors raise CrossrefError.
         try:
             metadata = Metadata(
                 record,
                 via="inveniordm",
-                depositor=current_app.config.get("CROSSREF_DEPOSITOR"),
-                email=current_app.config.get("CROSSREF_EMAIL"),
-                registrant=current_app.config.get("CROSSREF_REGISTRANT"),
+                url=registered_url,
             )
-            return write_crossref_xml(metadata)
+            crossref_xml = write_crossref_xml(metadata)
+            head = {
+                "depositor": current_app.config.get("CROSSREF_DEPOSITOR"),
+                "email": current_app.config.get("CROSSREF_EMAIL"),
+                "registrant": current_app.config.get("CROSSREF_REGISTRANT"),
+            }
+            return tostring(crossref_xml, head=head)
         except CrossrefError as e:
             current_app.logger.error(
                 f"CrossrefError while converting {metadata.id} to Crossref XML: {str(e)}"
             )
             return ""
-
-    @classmethod
-    def crossref_xml_tostring(cls, record):
-        """Stringify a Crossref XML record."""
-        return record

invenio_rdm_records/services/components/pids.py

@@ -304,6 +304,34 @@ def publish(self, identity, draft=None, record=None):
         #       already published records that don't have one (i.e. legacy records).
         # Create all missing PIDs (this happens only on first publish)
         missing_required_schemes = required_schemes - current_schemes
+
+        # Clean up any PIDs without identifier BEFORE adding new ones
+        # This handles cases where previous runs may have set provider/prefix without identifier
+        for scheme in list(current_pids.keys()):
+            if "identifier" not in current_pids[scheme]:
+                del current_pids[scheme]
+
+        # Copy provider and prefix from child record PIDs to ensure consistency
+        child_pids = draft.get("pids", {})
+        for scheme in missing_required_schemes:
+            # Only add provider/prefix info if:
+            # 1. Child has this PID type
+            # 2. Parent doesn't already have it in current_pids (after cleanup)
+            # 3. Parent doesn't have it in the actual record (defensive check)
+            if (
+                scheme in child_pids
+                and scheme not in current_pids
+                and not record.parent.pids.get(scheme)
+            ):
+                # Copy provider from child to parent
+                current_pids[scheme] = {
+                    "provider": child_pids[scheme].get("provider"),
+                }
+                # Extract prefix from the child's identifier
+                child_identifier = child_pids[scheme].get("identifier", "")
+                if child_identifier and "/" in child_identifier:
+                    current_pids[scheme]["prefix"] = child_identifier.split("/")[0]
+
         pids = self.service.pids.parent_pid_manager.create_all(
             record.parent,
             pids=current_pids,

invenio_rdm_records/services/pids/manager.py

@@ -143,6 +143,11 @@ def create(self, draft, scheme, identifier=None, provider_name=None):
         """
         provider = self._get_provider(scheme, provider_name)
         pid_attrs = {}
+        # Extract prefix from existing PID metadata if available
+        prefix = (
+            draft.pids.get(scheme, {}).get("prefix") if draft.pids.get(scheme) else None
+        )
+
         if identifier is not None:
             try:
                 pid = provider.get(identifier)
@@ -157,7 +162,9 @@ def create(self, draft, scheme, identifier=None, provider_name=None):
                 )
             pid_attrs = {"identifier": identifier, "provider": provider.name}
         else:
-            if draft.pids.get(scheme):
+            # Only raise error if an identifier already exists
+            # PIDs with only provider/prefix (without identifier) are incomplete and should be allowed
+            if draft.pids.get(scheme, {}).get("identifier"):
                 raise ValidationError(
                     message=_("A PID already exists for type {scheme}").format(
                         scheme=scheme
@@ -169,7 +176,11 @@ def create(self, draft, scheme, identifier=None, provider_name=None):
                     message=_("External identifier value is required."),
                     field_name=f"pids.{scheme}",
                 )
-            pid = provider.create(draft)
+            # Generate ID with optional prefix override
+            pid_kwargs = {}
+            if prefix:
+                pid_kwargs["prefix"] = prefix
+            pid = provider.create(draft, **pid_kwargs)
             pid_attrs = {"identifier": pid.pid_value, "provider": provider.name}
 
         if provider.client:  # provider and identifier already in dict
@@ -183,16 +194,42 @@ def create_all(self, draft, pids=None, schemes=None):
 
         # Create with an identifier value provided
         for scheme, pid_attrs in (pids or {}).items():
+            # Temporarily store prefix in draft.pids for create() to read
+            prefix = pid_attrs.get("prefix")
+            if prefix:
+                if scheme not in draft.pids:
+                    draft.pids[scheme] = {"prefix": prefix}
+                elif "prefix" not in draft.pids[scheme]:
+                    draft.pids[scheme]["prefix"] = prefix
+
             result[scheme] = self.create(
                 draft,
                 scheme,
-                pid_attrs["identifier"],
+                pid_attrs.get("identifier"),
                 pid_attrs.get("provider"),
             )
 
         # Create without an identifier value provided (only the scheme)
+        # Use provider and prefix from pids dict if available
         for scheme in schemes or []:
-            result[scheme] = self.create(draft, scheme)
+            pid_attrs = (pids or {}).get(scheme, {})
+            provider_name = pid_attrs.get("provider")
+
+            # Temporarily store prefix in draft.pids for create() to read
+            prefix = pid_attrs.get("prefix")
+            if prefix and scheme not in draft.pids:
+                draft.pids[scheme] = {"prefix": prefix}
+            elif prefix and scheme in draft.pids:
+                # Preserve existing prefix if not already set
+                if "prefix" not in draft.pids[scheme]:
+                    draft.pids[scheme]["prefix"] = prefix
+
+            result[scheme] = self.create(draft, scheme, provider_name=provider_name)
+
+        # Strip transient 'prefix' field from results - it's not part of the
+        # JSON schema and should not be persisted on the record.
+        for scheme_attrs in result.values():
+            scheme_attrs.pop("prefix", None)
 
         return result
 
@@ -247,10 +284,7 @@ def discard(self, scheme, identifier, provider_name=None, soft_delete=False):
         if not provider.can_modify(pid) and not soft_delete:
             raise ValidationError(
                 message=[
-                    _(
-                        "Cannot discard a reserved or registered persistent "
-                        "identifier."
-                    ),
+                    _("Cannot discard a reserved or registered persistent identifier."),
                 ],
                 field_name=f"pids.{scheme}",
             )
@@ -303,5 +337,5 @@ def create_and_reserve(self, record, **kwargs):
         """Create and reserve a PID for the given record, and update the record with the reserved PID."""
         pids = record.get("pids", {})
         provider_pid_dicts = self._get_providers(pids)
-        for provider, _ in provider_pid_dicts:
+        for provider, pid_dict in provider_pid_dicts:
             provider.create_and_reserve(record)

invenio_rdm_records/services/pids/providers/base.py

@@ -83,7 +83,7 @@ def create(self, record, pid_value=None, status=None, **kwargs):
         if pid_value is None:
             if not self.is_managed():
                 raise ValueError(_("You must provide a pid value."))
-            pid_value = self.generate_id(record)
+            pid_value = self.generate_id(record, **kwargs)
 
         try:
             pid = self.get(pid_value)
@@ -98,10 +98,14 @@ def create(self, record, pid_value=None, status=None, **kwargs):
                 status=status or self.default_status,
             )
 
-        # re-activate if previously deleted
+        # PID exists - check if it can be reused
+        # Re-activate if previously deleted
         if pid.is_deleted():
             pid.sync_status(PIDStatus.NEW)
             return pid
+        # If PID exists and belongs to the same record, return it (idempotent)
+        elif pid.object_uuid == record.id:
+            return pid
         else:
             raise PIDAlreadyExists(self.pid_type, pid_value)