feat: schedule globals (#10)

* feat: schedule globals

* fix: update `publishScheduledPost` for globals

* update readme

* fix test

Author: wkentdag

README.md

@@ -19,12 +19,15 @@ import { buildConfig } from 'payload/config'
 import { ScheduledPostPlugin } from 'payload-plugin-scheduler'
 import Pages from './collections/Pages'
 import Posts from './collections/Posts'
+import Home from './globals/Home'
 
 export default buildConfig({
   collections: [Pages, Posts],
+  globals: [Home],
   plugins: [
     ScheduledPostPlugin({
       collections: ['pages', 'posts'],
+      globals: ['home'],
       interval: 10,
     })
   ]
@@ -35,10 +38,16 @@ export default buildConfig({
 
 ## Options
 
-### `collections: string[]`
+At least one collection / global is required.
+
+### `collections?: string[]`
 
 An array of collection slugs. All collections must have drafts enabled.
 
+### `globals?: string[]`
+
+An array of global slugs. All globals must have drafts enabled.
+
 ### `interval?: number`
 
 Specify how frequently to check for scheduled posts (in minutes).
@@ -68,8 +77,8 @@ Collection added by the plugin to store pending schedule updates. Can be customi
 A configurable timer checks for any posts to be scheduled in the upcoming interval window. For each hit, it creates a separate job that's fired at that document's `publish_date` (via [node-schedule](https://github.com/node-schedule/node-schedule)). The idea here is that you can configure your interval window to avoid super long running tasks that are more prone to flaking.
 
 
-## Notes
+## Caveats
 
-Since the plugin uses cron under the hood, it depends on a long-running server and is incompatible with short-lived/serverless environments like ECS, or Vercel if you're using Payload 3.0 beta.
+* This plugin doesn't support Payload 3.0 beta. I intend to update it once 3.0 is stable, but it'll require substantial re-architecting to work in a serverless environment.
 
-I developed this plugin for a project that hasn't gone live yet. It has good test coverage but not in the wild yet -- there's your disclaimer.
+* There's no logic in place to dedupe schedules across multiple instances of a single app (see https://github.com/wkentdag/payload-plugin-scheduler/issues/9)

dev/src/globals/Home.ts

@@ -0,0 +1,17 @@
+import type { GlobalConfig } from "payload/types";
+
+const Home: GlobalConfig = {
+  slug: 'home',
+  versions: {
+    drafts: true,
+  },
+  fields: [
+    {
+      name: 'title',
+      type: 'text',
+    }
+  ]
+
+}
+
+export default Home

dev/src/payload.base.config.ts

@@ -10,6 +10,7 @@ import PagesWithExtraHooks from "./collections/PagesWithExtraHooks";
 
 // @ts-expect-error
 import { ScheduledPostPlugin } from '../../src'
+import Home from "./globals/Home";
 
 export const INTERVAL = 1
 
@@ -35,6 +36,7 @@ export const baseConfig: Omit<Config, 'db'> = {
   },
   editor: slateEditor({}),
   collections: [Pages, PagesWithExtraHooks, Posts, Users],
+  globals: [Home],
   typescript: {
     outputFile: path.resolve(__dirname, 'payload-types.ts'),
   },
@@ -44,6 +46,7 @@ export const baseConfig: Omit<Config, 'db'> = {
   plugins: [
     (ScheduledPostPlugin({
       collections: ['pages', 'posts', 'pageswithextrahooks'],
+      globals: ['home'],
       interval: INTERVAL,
       scheduledPosts: {
         admin: {

dev/test/plugin.spec.ts

@@ -27,7 +27,7 @@ describe('Plugin tests', () => {
       },
     })
 
-  it('schedules posts', async () => {
+  it('schedules collection docs', async () => {
     const pubDate = addMinutes(new Date(), 2).toISOString()
     const doc = await payload.create({
       collection: 'posts',
@@ -51,6 +51,37 @@ describe('Plugin tests', () => {
     expect(schedule.status).toBe('queued')
   })
 
+  it('schedules global docs', async () => {
+    const pubDate = addMinutes(new Date(), 2).toISOString()
+    const doc = await payload.updateGlobal({
+      slug: 'home',
+      data: {
+        title: 'hello world',
+        publish_date: pubDate,
+        _status: 'draft',
+      },
+    })
+
+    expect(doc.publish_date).toBe(pubDate)
+    expect(doc._status).toBe('draft')
+
+    const {
+      totalDocs,
+      docs: [schedule],
+    } = await payload.find({
+      collection: 'scheduled_posts',
+      where: {
+        global: {
+          equals: 'home'
+        }
+      }
+    })
+
+    expect(totalDocs).toBe(1)
+    expect(schedule.date).toBe(doc.publish_date)
+    expect(schedule.status).toBe('queued')
+  })
+
   it('bounds publish_date', async () => {
     const now = new Date()
     const futureDate = addMinutes(now, 10)

src/collections/ScheduledPosts.ts

@@ -22,13 +22,18 @@ const ScheduledPosts = (scheduleConfig: ScheduledPostConfig): CollectionConfig =
           name: 'post',
           type: 'relationship',
           unique: true,
-          required: true,
-          relationTo: [...scheduleConfig.collections],
+          relationTo: [...(scheduleConfig.collections || [])],
           hasMany: false,
           admin: {
             readOnly: true,
           },
         },
+        {
+          name: 'global',
+          type: 'select',
+          options: [...(scheduleConfig.globals || [])],
+          unique: true,
+        },
         {
           name: 'date',
           index: true,

src/hooks/boundPublishDate.ts

@@ -1,11 +1,11 @@
-import type { CollectionBeforeChangeHook } from 'payload/types'
+import type { CollectionBeforeChangeHook, GlobalBeforeChangeHook } from 'payload/types'
 import type { ScheduledPostConfig } from '../types'
 
 export default function boundPublishDate(
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
   scheduleConfig: ScheduledPostConfig,
-): CollectionBeforeChangeHook {
-  return ({ data }) => {
+): CollectionBeforeChangeHook | GlobalBeforeChangeHook {
+  return ({ data }: { data: any }) => {
     // eslint-disable-next-line no-underscore-dangle
     const isPublishing = data?._status === 'published'
     const pubDate = data?.publish_date ? new Date(data.publish_date) : undefined

src/hooks/syncSchedule.ts

@@ -1,39 +1,55 @@
-import { type CollectionAfterChangeHook } from 'payload/types'
+import type { GlobalAfterChangeHook, Where, CollectionAfterChangeHook } from 'payload/types'
 import { type ScheduledPostConfig } from '../types'
 import { debug } from '../util'
 
+type GlobalArgs = Parameters<GlobalAfterChangeHook>[0]
+type CollectionArgs = Parameters<CollectionAfterChangeHook>[0]
+
+function isGlobal(args:  CollectionArgs| GlobalArgs): args is GlobalArgs {
+  return (args as GlobalArgs).global !== undefined
+}
+
 export default function syncSchedule(
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
   scheduleConfig: ScheduledPostConfig,
-): CollectionAfterChangeHook {
-  return async ({ collection, doc, previousDoc, req }) => {
+): CollectionAfterChangeHook | GlobalAfterChangeHook {
+  return async (args: GlobalArgs | CollectionArgs) => {
+    const { doc, previousDoc, req } = args
+    const slug = isGlobal(args) ? args.global.slug : args.collection.slug
+    
     const { payload } = req
-    debug(`syncSchedule ${collection.slug} ${doc.id}`)
+    debug(`syncSchedule ${slug} ${doc.id}`)
     // eslint-disable-next-line no-underscore-dangle
     const isPublishing = doc._status === 'published'
     const publishInFuture = doc?.publish_date && new Date(doc.publish_date) > new Date()
     const scheduleChanged = doc?.publish_date !== previousDoc?.publish_date
     try {
       if (isPublishing || scheduleChanged) {
         debug('Deleting previous schedule')
-        // if `publish_date` is modified, remove any pending schedulers.
+        // if `publish_date` is modified, or the post is being published, remove any pending schedulers.
         // there should only ever be a single result here in practice
-        const deleted = await payload.delete({
-          collection: 'scheduled_posts',
-          where: {
-            and: [
-              {
-                'post.value': {
-                  equals: doc.id,
-                },
+        const whereClause: Where = isGlobal(args) ? {
+          global: {
+            equals: slug,
+          }
+        } : {
+          and: [
+            {
+              'post.value': {
+                equals: doc.id,
               },
-              {
-                'post.relationTo': {
-                  equals: collection.slug,
-                },
+            },
+            {
+              'post.relationTo': {
+                equals: slug,
               },
-            ],
-          },
+            },
+          ],
+        }
+
+        const deleted = await payload.delete({
+          collection: 'scheduled_posts',
+          where: whereClause,
           req,
         })
 
@@ -48,29 +64,36 @@ export default function syncSchedule(
 
       // if the publish date has changed and it's in the future, schedule it
       if (scheduleChanged && publishInFuture) {
-        debug('Scheduling post', collection.slug, doc.id)
-        let dbValue = doc.id
+        debug('Scheduling post', slug, doc.id)
+        const data: Record<string, any> = {
+          date: doc.publish_date,
+          status: 'queued',
+        }
 
-        // nb without this payload will throw a ValidationError
-        // seems like a bug
-        if (payload.db.defaultIDType === 'number') {
-          dbValue = Number(doc.id)
+        if (isGlobal(args)) {
+          data.global = slug
+        } else {
+          let dbValue = doc.id
+
+          // nb without this payload will throw a ValidationError
+          // seems like a bug
+          if (payload.db.defaultIDType === 'number') {
+            dbValue = Number(doc.id)
+          }
+
+          data.post = {
+            value: dbValue,
+            relationTo: slug,
+          }
         }
 
         const res = await payload.create({
           collection: 'scheduled_posts',
-          data: {
-            post: {
-              value: dbValue,
-              relationTo: collection.slug,
-            },
-            date: doc.publish_date,
-            status: 'queued',
-          },
+          data,
           req,
         })
 
-        debug(`scheduled ${collection.slug}:${dbValue} ${res.id}`)
+        debug(`scheduled ${slug}:${doc.id} ${res.id}`)
       }
     } catch (error: unknown) {
       payload.logger.error('[payload-plugin-scheduler] Error scheduling post')

src/init.ts

@@ -26,7 +26,7 @@ export const onInit = (config: ScheduledPostConfig, payload: Payload): Job => {
     //  scheduled to fire at its publish_date
     await Promise.all(
       queued.map(async schedule => {
-        const { date, post } = schedule
+        const { date, post, global } = schedule
         const id = schedule.id.toString()
         // overwrite any existing job for this same document
         if (Object.keys(scheduledJobs).includes(id)) {
@@ -37,7 +37,7 @@ export const onInit = (config: ScheduledPostConfig, payload: Payload): Job => {
           }
         }
 
-        const job = new Job(id, publishScheduledPost({ post }, payload))
+        const job = new Job(id, publishScheduledPost({ post, global }, payload))
 
         const scheduled = job.schedule(date)
 

src/lib.ts

@@ -42,26 +42,34 @@ export async function getUpcomingPosts(
 }
 
 export function publishScheduledPost(
-  { post }: Pick<ScheduledPost, 'post'>,
+  { post, global }: Pick<ScheduledPost, 'post' | 'global'>,
   payload: Payload,
 ): JobCallback {
   return async () => {
-    payload.logger.info(`Publishing ${post.relationTo} ${post.value}`)
-    debug(`Publishing ${post.relationTo} ${post.value}`)
+    const tag = global || `${post!.relationTo} ${post!.value}`
+    payload.logger.info(`Publishing ${tag}`)
+    debug(`Publishing ${tag}`)
+
+    const updateOp = (): ReturnType<typeof payload.updateGlobal> => global ? payload.updateGlobal({
+      slug: global,
+      data: {
+        _status: 'published'
+      }
+    }) : payload.update({
+      id: post!.value,
+      collection: post!.relationTo,
+      data: {
+        _status: 'published',
+      },
+    })
 
     try {
-      await payload.update({
-        id: post.value,
-        collection: post.relationTo,
-        data: {
-          _status: 'published',
-        },
-      })
-      payload.logger.info(`[payload-plugin-scheduler] Published ${post.relationTo} ${post.value}`)
+      await updateOp()
+      payload.logger.info(`[payload-plugin-scheduler] Published ${tag}`)
     } catch (error: unknown) {
-      debug(`Error publishing ${post.relationTo} ${post.value} ${error?.toString()}`)
+      debug(`Error publishing ${tag} ${error?.toString()}`)
       payload.logger.error(error, 
-        `[payload-plugin-scheduler] Failed to publish ${post.relationTo} ${post.value}`
+        `[payload-plugin-scheduler] Failed to publish ${tag}`
       )
     }
   }