feat: implement update_draft_from_markdown for 0.7.0

Author: ma2za

substack/api.py

@@ -464,6 +464,95 @@ def export_draft_to_markdown(self, draft_id):
             "unsupported_nodes": unsupported_nodes,
         }
 
+    def update_draft_from_markdown(
+        self,
+        draft_id: int,
+        markdown: str,
+        *,
+        subtitle: str = None,
+        audience: str = None,
+        write_comment_permissions: str = None,
+        search_engine_title: str = None,
+        search_engine_description: str = None,
+        slug: str = None,
+        draft_section_id: int = None,
+        tags=None,
+        dry_run: bool = False,
+    ) -> dict:
+        """
+        Update an existing draft body from Markdown, with optional metadata changes.
+        """
+        from substack.mdexport import document_to_markdown
+        from substack.post import Post
+
+        draft = self.get_draft(draft_id)
+        draft_body = draft.get("draft_body")
+        if isinstance(draft_body, str):
+            try:
+                draft_body = json.loads(draft_body)
+            except json.JSONDecodeError as exc:
+                raise ValueError(
+                    "Malformed draft body: draft_body is not valid JSON"
+                ) from exc
+        if not isinstance(draft_body, dict):
+            raise ValueError("Malformed draft body: draft_body must be a JSON object")
+
+        _, unsupported_nodes = document_to_markdown(draft_body)
+        if unsupported_nodes:
+            raise ValueError(
+                "Refusing to update: remote draft contains unsupported Substack nodes. "
+                "Export it first or remove the nodes manually to avoid data loss."
+            )
+
+        post = Post(
+            title=draft.get("title", ""),
+            subtitle=(
+                subtitle if subtitle is not None else (draft.get("subtitle") or "")
+            ),
+            user_id=self.get_user_id(),
+            audience=audience,
+            write_comment_permissions=write_comment_permissions,
+        )
+        post.from_markdown(markdown, api=self)
+
+        update_payload = {"draft_body": json.dumps(post.draft_body)}
+
+        if subtitle is not None:
+            update_payload["subtitle"] = subtitle
+        if audience is not None:
+            update_payload["audience"] = audience
+        if write_comment_permissions is not None:
+            update_payload["write_comment_permissions"] = write_comment_permissions
+        if search_engine_title is not None:
+            update_payload["search_engine_title"] = search_engine_title
+        if search_engine_description is not None:
+            update_payload["search_engine_description"] = search_engine_description
+        if slug is not None:
+            update_payload["slug"] = slug
+        if draft_section_id is not None:
+            update_payload["draft_section_id"] = draft_section_id
+
+        tags_result = None
+        updated_draft = draft
+
+        if not dry_run:
+            updated_draft = self.put_draft(draft_id, **update_payload)
+
+            tags_list = Api._normalize_tags(tags)
+            if tags_list:
+                tags_result = self.add_tags_to_post(draft_id, tags_list)
+
+        return {
+            "action": "update",
+            "draft_id": draft_id,
+            "dry_run": dry_run,
+            "changed": not dry_run,
+            "payload": update_payload,
+            "draft": updated_draft,
+            "tags": tags_result,
+            "unsupported_nodes": unsupported_nodes,
+        }
+
     def delete_draft(self, draft_id):
         """
 

substack/cli.py

@@ -309,6 +309,53 @@ def _drafts_create(api, args):
         print(f"Created draft {draft.get('id')}: {title}")
 
 
+def _drafts_update(api, args):
+    if not args.yes and (args.json_output or not sys.stdin.isatty()):
+        raise CLIUsageError("--yes is required in non-interactive or JSON mode")
+
+    markdown_file = Path(args.markdown_file)
+    if not markdown_file.exists():
+        raise CLIUsageError(f"File not found: {markdown_file}")
+
+    if not args.yes:
+        action = "update" if not args.dry_run else "dry-run update"
+        print(f"Ready to {action} draft {args.draft_id} from {markdown_file}")
+        print("Substack nodes that are not supported by Markdown export/import")
+        print("will cause the update to be refused to prevent data loss.")
+        print()
+        try:
+            response = input(f"Confirm {action}? [y/N]: ")
+            if response.lower() not in ["y", "yes"]:
+                print("Aborted.")
+                return
+        except EOFError as exc:
+            raise CLIUsageError(
+                f"Confirm {action} requires confirmation or --yes"
+            ) from exc
+
+    markdown = markdown_file.read_text(encoding="utf-8")
+
+    result = api.update_draft_from_markdown(
+        args.draft_id,
+        markdown,
+        subtitle=args.subtitle,
+        audience=args.audience,
+        write_comment_permissions=args.write_comment_permissions,
+        search_engine_title=args.search_engine_title,
+        search_engine_description=args.search_engine_description,
+        slug=args.slug,
+        draft_section_id=args.draft_section_id,
+        tags=args.tags,
+        dry_run=args.dry_run,
+    )
+
+    if args.json_output:
+        _print_json(result)
+    else:
+        status = "Dry-run updated" if args.dry_run else "Updated"
+        print(f"{status} draft {args.draft_id}")
+
+
 def _drafts_export(api, args):
     output_path = Path(args.output) if args.output else None
     if output_path is not None and output_path.exists() and not args.force:
@@ -447,6 +494,23 @@ def _build_parser():
     drafts_create.add_argument("--tag", action="append", dest="tags", metavar="TAG")
     drafts_create.set_defaults(handler=_drafts_create)
 
+    drafts_update = draft_commands.add_parser(
+        "update", help="Update a draft from a Markdown file."
+    )
+    drafts_update.add_argument("draft_id", type=int)
+    drafts_update.add_argument("markdown_file", metavar="MARKDOWN_FILE")
+    drafts_update.add_argument("--subtitle")
+    drafts_update.add_argument("--audience")
+    drafts_update.add_argument("--write-comment-permissions")
+    drafts_update.add_argument("--search-engine-title")
+    drafts_update.add_argument("--search-engine-description")
+    drafts_update.add_argument("--slug")
+    drafts_update.add_argument("--draft-section-id", type=int)
+    drafts_update.add_argument("--tag", action="append", dest="tags", metavar="TAG")
+    drafts_update.add_argument("--dry-run", action="store_true")
+    drafts_update.add_argument("--yes", action="store_true")
+    drafts_update.set_defaults(handler=_drafts_update)
+
     drafts_export = draft_commands.add_parser(
         "export", help="Export a draft to Markdown without modifying it."
     )

tests/substack/test_api_update.py

@@ -0,0 +1,23 @@
+from unittest.mock import Mock, patch
+
+import pytest
+
+from substack import Api
+
+
+def test_update_draft_from_markdown_basic(monkeypatch):
+    api = Api.__new__(Api)
+    api.publication_url = "https://test.substack.com"
+    mock_get_user_id = Mock(return_value=1)
+    monkeypatch.setattr(api, "get_user_id", mock_get_user_id)
+    mock_get_draft = Mock(
+        return_value={"id": 42, "draft_body": '{"type":"doc","content":[]}'}
+    )
+    monkeypatch.setattr(api, "get_draft", mock_get_draft)
+    mock_put_draft = Mock(return_value={"id": 42})
+    monkeypatch.setattr(api, "put_draft", mock_put_draft)
+    res = api.update_draft_from_markdown(42, "Updated content")
+    assert res["action"] == "update"
+    assert res["draft_id"] == 42
+    assert res["dry_run"] is False
+    assert mock_put_draft.called

tests/substack/test_cli_update.py

@@ -0,0 +1,61 @@
+import json
+from pathlib import Path
+
+import pytest
+
+from substack import cli
+
+
+class UpdateOperationsApi:
+    def __init__(self):
+        self.calls = []
+
+    def update_draft_from_markdown(self, draft_id, markdown, **kwargs):
+        self.calls.append(("update", draft_id, markdown, kwargs))
+        return {
+            "action": "update",
+            "draft_id": draft_id,
+            "dry_run": kwargs.get("dry_run", False),
+            "changed": not kwargs.get("dry_run", False),
+            "payload": {},
+            "draft": {"id": draft_id},
+            "tags": None,
+            "unsupported_nodes": [],
+        }
+
+
+def use_api(monkeypatch, mock_api):
+    monkeypatch.setattr(cli, "_api_from_env", lambda **kw: mock_api)
+
+
+def test_drafts_update_requires_yes_in_json_mode(tmp_path, monkeypatch, capsys):
+    api = UpdateOperationsApi()
+    use_api(monkeypatch, api)
+    md_file = tmp_path / "test.md"
+    md_file.write_text("# Test", encoding="utf-8")
+    assert cli.main(["--json", "drafts", "update", "42", str(md_file)]) == 2
+    err = capsys.readouterr().err
+    assert "requires" in err or "required" in err
+    assert "--yes" in err
+    assert api.calls == []
+
+
+def test_drafts_update_json_dry_run(tmp_path, monkeypatch, capsys):
+    api = UpdateOperationsApi()
+    use_api(monkeypatch, api)
+    md_file = tmp_path / "test.md"
+    md_file.write_text("# Test", encoding="utf-8")
+    assert (
+        cli.main(
+            ["--json", "drafts", "update", "42", str(md_file), "--dry-run", "--yes"]
+        )
+        == 0
+    )
+    out = json.loads(capsys.readouterr().out)
+    assert out["action"] == "update"
+    assert out["draft_id"] == 42
+    assert out["dry_run"] is True
+    assert api.calls[0][0] == "update"
+    assert api.calls[0][1] == 42
+    assert api.calls[0][2] == "# Test"
+    assert api.calls[0][3]["dry_run"] is True