afterChange collection hook and drafts

[cbratschi]

Link to reproduction

private repo

Describe the Bug

The previousDoc value always returns either the last published version of the document or the last saved draft. This makes it difficult to react on field changes between published versions. For instance we want to add redirects whenever a slug changes but comparing previousDoc.slug to doc.slug will be wrong whenever a draft version was created in between.

The problem is there is no workaround available because in afterChange the last published version is already overwritten if the user publishes the changes.

A solution would be to add a originalDoc property which is equal to the last published version or last available draft if the document was not published before. This would make state handling much easier.

The documentation should be extended to include all necessary details.

To Reproduce

1. create collection using draft
2. add afterChange hook
3. monitor previousDoc value

Payload Version

2.3.1

Adapters and Plugins

db-mongodb, bundler-webpack, live-preview

[cbratschi]

Have the same problem in a revalidate hook for Next.js. In afterChange it's impossible to distinguish the following state changes:

• published (last saved) to draft
• draft (last saved) to published

Therefore every afterChange call leads to a revalidation i.e. much too often while editing because of the intermediate draft calls.

[cbratschi]

A partial workaround is to switch to the beforeChange hook and read the last saved document through the local API:

//Note: only works here, afterChange hook runs too late!
if (originalDoc._status === 'draft') {
    //get last published
    originalDoc = await payload.findByID({
        //@ts-ignore
        collection: collection.slug,
        id: originalDoc.id, //Note: data contains no id
        depth: 0,
        draft: false,
        locale: lang,
        //Note: needed or falls back to default language!
        //Note: returns undefined value on first save
        fallbackLocale: lang
    });

    //Note: right now always getting a document but could be a draft
    if (!originalDoc || originalDoc._status === 'draft') {
        if (DEBUG) {
            console.log('-> could not find last published document');
        }

        return;
    }

    if (DEBUG) {
        console.log('-> read last published document');

        //debug
        //console.dir(originalDoc);
    }
}

However, this has some drawbacks and won't work for revalidation hooks. Here the document has to be saved first.

findById() has some strange behaviors:

• Draft query is set to false but still getting a draft document if no document was published yet.
• We use a default locale and a fallback in the Payload settings. To know a translation exists, we have to set fallbackLocale to the locale value. In this case we get undefined values being returned or values being pre-processed by other hooks. I would prefer having an API which does not return invalid documents in case a translation does not exist yet.

Update: tried "fallbackLocale: 'none'" but this made no difference.

[JarrodMFlesch]

@cbratschi I am trying to follow along with your issue here. I believe you could accomplish this by writing to the req's context in a beforeChange hook and reading from it in the afterChange hook:

// beforeChange hook

let transitionState: 'fromPublishToDraft' | 'fromDraftToPublish' | null = null
if (originalDoc._status === 'draft' && data?._status === 'published') {
  transitionState = 'fromDraftToPublish'
} else if (originalDoc._status === 'published' && data?._status === 'draft') {
  transitionState = 'fromPublishToDraft'
}

req.context = {
  ...req.context,
  transitionState: transitionState || undefined, 
}

And then in your afterChange hook you could read from the req.context and determine if the document is transitioning from publish to draft or draft to publish or neither.

Does that sound like it would assist you with what you are looking to accomplish?

[cbratschi]

@JarrodMFlesch the situation is more complicated than that but the context could be used to pass data available at beforeChange to afterChange.

The follow transitions happen:

• edit a (original) document
• modify content
• document is saved as draft
  • beforeChange: originalDoc is the original document (correct naming)
• save document
  • beforeChange: originalDoc point to the last draft (points to the last saved document, not the original one)

We use the code listed above to read the real original document in beforeChange (see #4405 (comment)).

A workaround would be:

• beforeChange
  • read original document from database
  • pass original document to context
• afterChange
  • get original document from context (use for business logic)