@plutocms/supabase 0.26.0 → 0.28.0

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [0.28.0](https://github.com/plutocms/supabase/compare/v0.27.0...v0.28.0) (2026-11-08)
+
+
+### Features
+
+* scheduled publish and pending review ([#261](https://github.com/plutocms/supabase/issues/261)) ([2eb8653](https://github.com/plutocms/supabase/commit/2eb8653cd3fec38248c6bf44200c0e55b399afdd))
+
+## [0.27.0](https://github.com/plutocms/supabase/compare/v0.26.0...v0.27.0) (2026-11-07)
+
+
+### Features
+
+* the trash on Supabase (blog migration 009, shop migration 007) ([#252](https://github.com/plutocms/supabase/issues/252)) ([4821321](https://github.com/plutocms/supabase/commit/48213213721f58b1022a0a98e9c3c32f98c6a873))
+
 ## [0.26.0](https://github.com/plutocms/supabase/compare/v0.25.0...v0.26.0) (2026-11-07)
 
 

package/FEATURES.md

@@ -16,7 +16,7 @@ policies shared by every project here.
   @.claude/skills/users-and-roles/SKILL.md
 - Content adapter: a Supabase/PostgREST-backed `PlutoContentAdapter`, plugging any layer's
   declared content type into `@plutocms/core`'s generic content routes. It supports query
-  filters (a filter on a `multiple` reference matches a list column), the `status` of the admin list and `ids`, puts the timestamps on items, and reads the public API of core with an anonymous client.
+  filters (a filter on a `multiple` reference matches a list column), the `status` of the admin list, the trash (a `deleted_at` column, the service client for the scheduled purge), scheduled publish and review (the live rule, the publish time, `publishDue`) and `ids`, puts the timestamps on items, and reads the public API of core with an anonymous client.
   It keeps the revisions of every item (`pluto_content_revisions`, migration 011) for the History of core.
   It keeps a server copy of the unsaved changes of each editor (`pluto_content_backups`, migration
   012), so the edit form can offer them on another device.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@plutocms/supabase",
   "type": "module",
-  "version": "0.26.0",
+  "version": "0.28.0",
   "description": "Supabase backend layer for Pluto",
   "author": "Victor Ribeiro",
   "homepage": "https://github.com/plutocms/supabase/tree/main/packages/supabase#readme",
@@ -30,7 +30,7 @@
   "dependencies": {
     "@nuxt/ui": "^4.12.0",
     "@nuxtjs/supabase": "^2.1.0",
-    "@plutocms/core": ">=0.61.1 <1.0.0",
+    "@plutocms/core": ">=0.63.0 <1.0.0",
     "@supabase/supabase-js": "^2.117.3",
     "postgres": "^3.4.9",
     "supabase": "^2.121.0",

package/server/utils/content-adapter.ts

@@ -11,6 +11,7 @@ import {
   recordRevision,
   updateAction,
 } from './content-revisions'
+import { optionalServiceClient } from './service-client'
 
 /**
  * A Supabase client for one request, deliberately untyped.
@@ -40,6 +41,19 @@ import {
  * type, not to assert against one.
  */
 async function getClient(event: H3Event): Promise<SupabaseClient> {
+  // A system request (a scheduled task of core, such as the purge of the trash) has no user: it
+  // needs the service role key. Without the key it answers 401, and the task skips the type.
+  if (isPlutoSystemEvent(event)) {
+    const service = optionalServiceClient(event)
+    if (!service) {
+      throw createPlutoError({
+        statusCode: 401,
+        message: 'A system request needs the Supabase service role key.',
+        key: 'pluto.errors.unauthorized',
+      })
+    }
+    return service as unknown as SupabaseClient
+  }
   if (isPublicRead(event)) {
     return getAnonymousClient(event)
   }
@@ -254,6 +268,26 @@ function resolveFieldColumn(
   return fieldName
 }
 
+/**
+ * The column that marks a trashed row: `type.trash.column`, else `deleted_at`. `undefined` for a
+ * type with no trash. See the "Trash" of the content-model skill of core.
+ */
+export function resolveTrashColumn(type: PlutoContentType): string | undefined {
+  if (!type.trash) {
+    return undefined
+  }
+  return (typeof type.trash === 'object' && type.trash.column) || 'deleted_at'
+}
+
+/** Keeps the rows that are not in the trash, for a type with a trash. */
+function liveOnly<B extends { is: (column: string, value: null) => B }>(
+  builder: B,
+  type: PlutoContentType
+): B {
+  const column = resolveTrashColumn(type)
+  return column ? builder.is(column, null) : builder
+}
+
 /** Whether a field stores a list in one column: a `multiple` reference. */
 function isListField(type: PlutoContentType, fieldName: string): boolean {
   const field = type.fields.find((candidate) => candidate.name === fieldName)
@@ -261,6 +295,90 @@ function isListField(type: PlutoContentType, fieldName: string): boolean {
   return field?.type === 'reference' && field.multiple === true
 }
 
+/**
+ * Only the live rows: published, or scheduled with a time that has come (`isLiveStatus` of core).
+ * The read policies of the database have the same rule (`public.pluto_is_live`).
+ */
+function liveStatusFilter<
+  B extends {
+    eq: (column: string, value: unknown) => B
+    or: (filters: string) => B
+  },
+>(builder: B, type: PlutoContentType, statusColumn: string): B {
+  const rules = statusRules(type)!
+  if (rules.scheduled === undefined || !rules.publishedAtColumn) {
+    return builder.eq(statusColumn, rules.published)
+  }
+  const now = new Date().toISOString()
+  return builder.or(
+    `${statusColumn}.eq.${rules.published},and(${statusColumn}.eq.${rules.scheduled},${rules.publishedAtColumn}.lte."${now}")`
+  )
+}
+
+function publishCapability(type: PlutoContentType): string | undefined {
+  return type.capabilities?.publish ?? type.capabilities?.write
+}
+
+/**
+ * The publish time of a save, the same rule as the Git CMS. A scheduled save sets the planned time
+ * (`values.publishAt`, in the future; else 400). A scheduled item that keeps its status keeps its
+ * time when the payload has no new one. Publish now of a scheduled item stamps the time now, and a
+ * scheduled item that goes to a draft or to review loses its time. Else the first publish stamps
+ * the time. Answers the value to write, `null` to clear, or `undefined` to leave the column.
+ */
+function publishTimeFor(
+  type: PlutoContentType,
+  before: unknown,
+  after: unknown,
+  storedTime: unknown,
+  values: Record<string, unknown>
+): string | null | undefined {
+  const rules = statusRules(type)
+  if (!rules?.publishedAtColumn || after === undefined) {
+    return undefined
+  }
+  const now = Date.now()
+  if (rules.scheduled !== undefined && after === rules.scheduled) {
+    if (before !== rules.scheduled || Object.hasOwn(values, 'publishAt')) {
+      const key = scheduleError(type, values.publishAt, now)
+      if (key) {
+        throw createPlutoError({
+          statusCode: 400,
+          message: 'The schedule time is not valid.',
+          key,
+        })
+      }
+      return new Date(statusTime(values.publishAt)!).toISOString()
+    }
+    return undefined
+  }
+  if (rules.scheduled !== undefined && before === rules.scheduled) {
+    return after === rules.published ? new Date(now).toISOString() : null
+  }
+  if (after === rules.published && storedTime == null) {
+    return new Date(now).toISOString()
+  }
+  return undefined
+}
+
+/**
+ * A clear 403 before the write, when the status change needs the publish capability. The database
+ * refuses it too (`posts_status_guard`), but with a less clear error.
+ */
+async function requireStatusChange(
+  ctx: PlutoContentContext,
+  before: unknown,
+  after: unknown
+): Promise<void> {
+  if (isPlutoSystemEvent(ctx.event)) {
+    return
+  }
+  const capability = publishCapability(ctx.type)
+  if (capability && statusChangeNeedsPublish(ctx.type, before, after)) {
+    await requireCapability(ctx.event, capability)
+  }
+}
+
 async function list(
   ctx: PlutoContentContext,
   query: PlutoContentQuery
@@ -273,7 +391,10 @@ async function list(
   const client = await getClient(ctx.event)
   const pkColumn = ctx.type.primaryKey ?? 'id'
 
-  let builder = client.from(ctx.type.source).select('*', { count: 'exact' })
+  let builder = liveOnly(
+    client.from(ctx.type.source).select('*', { count: 'exact' }),
+    ctx.type
+  )
 
   if (query.ids) {
     builder = builder.in(pkColumn, query.ids)
@@ -281,9 +402,7 @@ async function list(
 
   const statusColumn = resolveStatusColumn(ctx.type)
   if (statusColumn && query.includeUnpublished !== true) {
-    const publishedValue =
-      (ctx.type.status && ctx.type.status.publishedValue) || 'published'
-    builder = builder.eq(statusColumn, publishedValue)
+    builder = liveStatusFilter(builder, ctx.type, statusColumn)
   }
 
   // Only one status. The status column has a default and no null, so an equality is enough.
@@ -362,11 +481,10 @@ async function get(
   const client = await getClient(ctx.event)
   const pkColumn = ctx.type.primaryKey ?? 'id'
 
-  const { data, error } = await client
-    .from(ctx.type.source)
-    .select('*')
-    .eq(pkColumn, idOrSlug)
-    .maybeSingle()
+  const { data, error } = await liveOnly(
+    client.from(ctx.type.source).select('*').eq(pkColumn, idOrSlug),
+    ctx.type
+  ).maybeSingle()
 
   if (error && !isInvalidIdShape(error)) {
     throw toContentError(error)
@@ -383,11 +501,10 @@ async function get(
       'slug.field'
     )
 
-    const bySlug = await client
-      .from(ctx.type.source)
-      .select('*')
-      .eq(slugColumn, idOrSlug)
-      .maybeSingle()
+    const bySlug = await liveOnly(
+      client.from(ctx.type.source).select('*').eq(slugColumn, idOrSlug),
+      ctx.type
+    ).maybeSingle()
 
     if (bySlug.error) {
       throw toContentError(bySlug.error)
@@ -423,6 +540,18 @@ async function create(
     } else if (ctx.type.status && ctx.type.status.default !== undefined) {
       row[statusColumn] = ctx.type.status.default
     }
+    await requireStatusChange(ctx, undefined, row[statusColumn])
+    const timeColumn = statusRules(ctx.type)?.publishedAtColumn
+    const time = publishTimeFor(
+      ctx.type,
+      undefined,
+      row[statusColumn],
+      undefined,
+      values
+    )
+    if (timeColumn && time !== undefined) {
+      row[timeColumn] = time
+    }
   }
 
   // A client never controls its own creation timestamp. Always stamp it,
@@ -478,7 +607,10 @@ async function update(
   // column name resolves to its own `GenericStringError` type instead of a
   // usable row shape.
   let existing: Record<string, unknown> | null = null
-  if (statusColumn && Object.hasOwn(values, 'status')) {
+  const publishApart =
+    ctx.type.capabilities?.publish !== undefined &&
+    ctx.type.capabilities.publish !== ctx.type.capabilities.write
+  if (statusColumn && (Object.hasOwn(values, 'status') || publishApart)) {
     const { data: stored, error: fetchError } = await client
       .from(ctx.type.source)
       .select('*')
@@ -492,18 +624,27 @@ async function update(
     existing = stored as Record<string, unknown> | null
   }
 
-  // Published-at preservation, generalizing supabase-blog's hand-written
-  // edit route: stamp published-at the first time a row is published, but
-  // never overwrite an already-set value on a later edit.
-  if (
-    statusColumn &&
-    ctx.type.status &&
-    ctx.type.status.publishedAtColumn &&
-    row[statusColumn] === ctx.type.status.publishedValue &&
-    existing &&
-    existing[ctx.type.status.publishedAtColumn] == null
-  ) {
-    row[ctx.type.status.publishedAtColumn] = new Date().toISOString()
+  // The status rules and the publish time (`publishTimeFor`): the first publish stamps the time
+  // and a later edit never overwrites it; a schedule sets the planned time.
+  if (statusColumn && existing) {
+    const before =
+      existing[statusColumn] ??
+      (ctx.type.status ? ctx.type.status.default : undefined)
+    const after = Object.hasOwn(values, 'status') ? values.status : before
+    await requireStatusChange(ctx, before, after)
+    const timeColumn = statusRules(ctx.type)?.publishedAtColumn
+    if (timeColumn && Object.hasOwn(values, 'status')) {
+      const time = publishTimeFor(
+        ctx.type,
+        before,
+        after,
+        existing[timeColumn],
+        values
+      )
+      if (time !== undefined) {
+        row[timeColumn] = time
+      }
+    }
   }
 
   const { data, error } = await client
@@ -609,11 +750,14 @@ async function countCreated(
   }
 
   const client = await getClient(ctx.event)
-  const { count, error } = await client
-    .from(ctx.type.source)
-    .select('*', { count: 'exact', head: true })
-    .gte(createdColumn, range.from)
-    .lt(createdColumn, range.to)
+  const { count, error } = await liveOnly(
+    client
+      .from(ctx.type.source)
+      .select('*', { count: 'exact', head: true })
+      .gte(createdColumn, range.from)
+      .lt(createdColumn, range.to),
+    ctx.type
+  )
 
   if (error) {
     throw toContentError(error)
@@ -622,12 +766,207 @@ async function countCreated(
   return count ?? 0
 }
 
+// --- Trash ------------------------------------------------------------------
+//
+// A trashed row has its trash column set (`resolveTrashColumn`). Moving it to the trash and back
+// is an update of that column; the purge is the real delete, so the delete triggers of the layers
+// (the references to a term or an author) run then. The migrations of the layers give the column
+// and the policies: visitors never read a trashed row, and staff with the delete capability does.
+
+function requireTrashColumn(type: PlutoContentType): string {
+  const column = resolveTrashColumn(type)
+  if (!column) {
+    throw createPlutoError({
+      statusCode: 404,
+      message: 'This content type has no trash.',
+      key: 'pluto.errors.noTrash',
+    })
+  }
+  return column
+}
+
+function notFound() {
+  return createPlutoError({
+    statusCode: 404,
+    message: 'Not found.',
+    key: 'pluto.errors.notFound',
+  })
+}
+
+async function moveToTrash(
+  ctx: PlutoContentContext,
+  id: string | number
+): Promise<void> {
+  const column = requireTrashColumn(ctx.type)
+  const client = await getClient(ctx.event)
+  const pkColumn = ctx.type.primaryKey ?? 'id'
+
+  const { data, error } = await client
+    .from(ctx.type.source)
+    .update({ [column]: new Date().toISOString() })
+    .eq(pkColumn, id)
+    .is(column, null)
+    .select('*')
+
+  if (error) {
+    throw toContentError(error)
+  }
+  if (!data || data.length === 0) {
+    throw notFound()
+  }
+}
+
+async function listTrash(
+  ctx: PlutoContentContext,
+  query: { limit?: number; offset?: number; search?: string }
+): Promise<PlutoContentListResult> {
+  const column = requireTrashColumn(ctx.type)
+  const client = await getClient(ctx.event)
+
+  let builder = client
+    .from(ctx.type.source)
+    .select('*', { count: 'exact' })
+    .not(column, 'is', null)
+
+  if (query.search) {
+    const titleColumn = resolveFieldColumn(
+      ctx.type,
+      ctx.type.titleField,
+      'titleField'
+    )
+    builder = builder.ilike(titleColumn, `%${query.search}%`)
+  }
+
+  builder = builder.order(column, { ascending: false })
+
+  const offset = query.offset ?? 0
+  const limit = query.limit ?? 50
+  builder = builder.range(offset, offset + limit - 1)
+
+  const { data, error, count } = await builder
+  if (error) {
+    throw toContentError(error)
+  }
+
+  return {
+    data: (data ?? []).map((row: Record<string, unknown>) => ({
+      ...toItem(ctx.type, row),
+      _deletedAt: row[column] ?? null,
+    })),
+    total: count ?? undefined,
+  }
+}
+
+async function restoreFromTrash(
+  ctx: PlutoContentContext,
+  id: string | number
+): Promise<PlutoContentItem> {
+  const column = requireTrashColumn(ctx.type)
+  const client = await getClient(ctx.event)
+  const pkColumn = ctx.type.primaryKey ?? 'id'
+
+  const { data, error } = await client
+    .from(ctx.type.source)
+    .update({ [column]: null })
+    .eq(pkColumn, id)
+    .not(column, 'is', null)
+    .select('*')
+
+  if (error) {
+    throw toContentError(error)
+  }
+  const row = data?.[0]
+  if (!row) {
+    throw notFound()
+  }
+  return toItem(ctx.type, row)
+}
+
+async function purge(
+  ctx: PlutoContentContext,
+  id: string | number
+): Promise<void> {
+  const column = requireTrashColumn(ctx.type)
+  const client = await getClient(ctx.event)
+  const pkColumn = ctx.type.primaryKey ?? 'id'
+
+  const { data, error } = await client
+    .from(ctx.type.source)
+    .delete()
+    .eq(pkColumn, id)
+    .not(column, 'is', null)
+    .select('*')
+
+  if (error) {
+    throw toContentError(error)
+  }
+  if (!data || data.length === 0) {
+    throw notFound()
+  }
+  await deleteRevisions(ctx, client, id)
+}
+
+async function purgeBefore(
+  ctx: PlutoContentContext,
+  before: string
+): Promise<number> {
+  const column = requireTrashColumn(ctx.type)
+  const client = await getClient(ctx.event)
+  const pkColumn = ctx.type.primaryKey ?? 'id'
+
+  const { data, error } = await client
+    .from(ctx.type.source)
+    .delete()
+    .lt(column, before)
+    .select('*')
+
+  if (error) {
+    throw toContentError(error)
+  }
+  const rows = (data ?? []) as Record<string, unknown>[]
+  for (const row of rows) {
+    await deleteRevisions(ctx, client, row[pkColumn] as string | number)
+  }
+  return rows.length
+}
+
 /** Delegates straight to `requireCapability`, unchanged. */
 async function authorize(event: H3Event, capability: string): Promise<void> {
   await requireCapability(event, capability)
 }
 
 /** Builds the Supabase/PostgREST-backed `PlutoContentAdapter`. Register it with `registerContentAdapter` from a `server/plugins/*.ts` file. */
+/**
+ * Publishes the scheduled rows whose time is `at` or earlier, and keeps their time. The scheduled
+ * task of core gives a system request (the service client); the admin list of a publisher gives
+ * the client of the user. Trashed rows stay.
+ */
+async function publishDue(
+  ctx: PlutoContentContext,
+  at: string
+): Promise<number> {
+  const rules = statusRules(ctx.type)
+  const statusColumn = resolveStatusColumn(ctx.type)
+  if (!rules?.scheduled || !rules.publishedAtColumn || !statusColumn) {
+    return 0
+  }
+  const client = await getClient(ctx.event)
+  const pkColumn = ctx.type.primaryKey ?? 'id'
+  const { data, error } = await liveOnly(
+    client
+      .from(ctx.type.source)
+      .update({ [statusColumn]: rules.published })
+      .eq(statusColumn, rules.scheduled)
+      .lte(rules.publishedAtColumn, at),
+    ctx.type
+  ).select(pkColumn)
+
+  if (error) {
+    throw toContentError(error)
+  }
+  return data?.length ?? 0
+}
+
 export function createSupabaseContentAdapter(): PlutoContentAdapter {
   return {
     id: 'supabase',
@@ -636,6 +975,14 @@ export function createSupabaseContentAdapter(): PlutoContentAdapter {
     create,
     update,
     remove,
+    trash: {
+      move: moveToTrash,
+      list: listTrash,
+      restore: restoreFromTrash,
+      purge,
+      purgeBefore,
+    },
+    publishDue,
     authorize,
     countCreated,
     timestampKeys,

package/shared/types/supabase.ts

@@ -89,18 +89,21 @@ export type Database = {
       product_availability: {
         Row: {
           created_at: string
+          deleted_at: string | null
           id: number
           label: string
           slug: string
         }
         Insert: {
           created_at?: string
+          deleted_at?: string | null
           id?: never
           label: string
           slug: string
         }
         Update: {
           created_at?: string
+          deleted_at?: string | null
           id?: never
           label?: string
           slug?: string
@@ -109,18 +112,21 @@ export type Database = {
       }
       product_category: {
         Row: {
+          deleted_at: string | null
           description: string | null
           id: number
           label: string
           slug: string
         }
         Insert: {
+          deleted_at?: string | null
           description?: string | null
           id?: never
           label: string
           slug: string
         }
         Update: {
+          deleted_at?: string | null
           description?: string | null
           id?: never
           label?: string
@@ -177,36 +183,45 @@ export type Database = {
           availability: number | null
           category: number | null
           created_at: string
+          deleted_at: string | null
           description: string | null
           id: number
           is_custom: boolean
           name: string
           price: number
+          published_at: string | null
           slug: string
+          status: string
           stock_quantity: number | null
         }
         Insert: {
           availability?: number | null
           category?: number | null
           created_at?: string
+          deleted_at?: string | null
           description?: string | null
           id?: never
           is_custom?: boolean
           name: string
           price: number
+          published_at?: string | null
           slug: string
+          status?: string
           stock_quantity?: number | null
         }
         Update: {
           availability?: number | null
           category?: number | null
           created_at?: string
+          deleted_at?: string | null
           description?: string | null
           id?: never
           is_custom?: boolean
           name?: string
           price?: number
+          published_at?: string | null
           slug?: string
+          status?: string
           stock_quantity?: number | null
         }
         Relationships: [