Method UploadAndAttach

internal/attachments/attach.go:30–64

UploadAndAttach uploads assets in order and stops at the first failure. It points existing references at the URLs of successful uploads and appends only successful uploads the markdown did not reference. Assets after a failure are not attempted. The result reports how many assets reached the server

(ctx context.Context, md string, assets []UserAsset)

// The markdown is returned unchanged when it could not be rewritten, so a
// caller that assigns the result in place never destroys what it was given.
func (u *Uploader) UploadAndAttach(ctx context.Context, md string, assets []UserAsset) (string, UploadResult, error) {
	args := make([]attachmentArg, len(assets))
	for i, a := range assets {
		f := a.getAsset()
		args[i] = attachmentArg{Path: f.path, Alt: f.alt, RendersAsPlayer: a.rendersAsPlayer()}
	}

	attachableMD, err := newAttachableMarkdown(md, args)
	if err != nil {
		return md, UploadResult{}, err
	}

	var failures []error
	result := UploadResult{}
	for i, a := range assets {
		assetURL, err := u.upload(ctx, a)
		if err != nil {
			// Stopping at the first failure. It makes recovery much simpler.
			failures = append(failures, err)
			break
		}
		args[i].URL = assetURL
		result.Uploaded++
	}

	attachedMD, err := attachAssetsToMarkdown(attachableMD)
	if err != nil {
		failures = append(failures, err)
		return md, result, errors.Join(failures...)
	}

	result.AppendOperations = len(attachedMD.ToAppend)
	result.ReplaceOperations = attachedMD.ReplaceOperations
	return appendUnreferenced(attachedMD, assets), result, errors.Join(failures...)
}

// appendUnreferenced adds a paragraph for every attachment the author never
// referenced, in the order they were attached. Each one renders itself, since