@btst/plugin-cms 1.0.0 → 1.2.0-beta.1

package/dist/api/operations.mjs

@@ -6,7 +6,16 @@ import { createListContentQuerySchema, DEFAULT_MAX_PAGE_SIZE, contentReadOptions
 import { slugify } from '../utils.mjs';
 import { serializeContentType, getAllContentItems, getContentItemBySlug, applyContentReadOptions, serializeContentItemWithType, getContentItemsByRelationForType, validateContentReadOptions, CMSContentSelectionError } from './getters.mjs';
 import { syncRelations, extractRelationFields, isNewRelationValue, isExistingRelationValue } from './relations.mjs';
+import { recordContentRevision } from './mutations.mjs';
+import { isPublishedContent } from './publication.mjs';
 
+const dispatchQueues = /* @__PURE__ */ new WeakMap();
+function freezeCMSOperationData(value) {
+  if (value && typeof value === "object") {
+    Object.values(value).forEach(freezeCMSOperationData);
+    Object.freeze(value);
+  }
+}
 function operationContentType(contentType) {
   return { ...contentType };
 }
@@ -55,13 +64,22 @@ const CMSContentItemParamsSchema = z.object({
   typeSlug: z.string().min(1),
   id: z.string().min(1)
 });
+const PublishAtSchema = z.iso.datetime({ offset: true }).nullable().optional();
+const CMSRevisionParamsSchema = CMSContentItemParamsSchema.extend({
+  revisionId: z.string().min(1)
+});
+const CMSRevisionsQuerySchema = z.object({
+  offset: z.coerce.number().int().min(0).default(0)
+});
 const CMSCreateContentItemBodySchema = z.object({
   slug: z.string().min(1),
-  data: CMSDataSchema
+  data: CMSDataSchema,
+  publishAt: PublishAtSchema
 });
 const CMSUpdateContentItemBodySchema = z.object({
   slug: z.string().min(1).optional(),
-  data: CMSDataSchema.optional()
+  data: CMSDataSchema.optional(),
+  publishAt: PublishAtSchema
 });
 const ListContentTypesInputSchema = EmptyInputSchema;
 const GetContentTypeInputSchema = CMSContentTypeParamsSchema;
@@ -194,7 +212,7 @@ async function getRecordOrThrow(adapter, ensureSynced, typeSlug, id) {
   }
   return item;
 }
-function recordFacts(item) {
+function recordFacts(item, view) {
   if (!item.contentType) {
     throw new CMSOperationError(
       500,
@@ -204,13 +222,14 @@ function recordFacts(item) {
   }
   return {
     contentType: item.contentType.slug,
+    ...view ? { view } : {},
     scope: "record",
     recordId: item.id,
     ...item.authorId ? { authorId: item.authorId } : {}
   };
 }
-function collectionFacts(contentType) {
-  return { contentType, scope: "collection" };
+function collectionFacts(contentType, view) {
+  return { contentType, scope: "collection", ...view ? { view } : {} };
 }
 function assertRecordFacts(item, facts) {
   if (!facts.recordId || item.id !== facts.recordId || item.contentType?.slug !== facts.contentType || (item.authorId ?? void 0) !== facts.authorId) {
@@ -258,7 +277,7 @@ function staleRecordError() {
   );
 }
 function assertRecordSnapshot(current, expected) {
-  if (current.id !== expected.id || current.contentTypeId !== expected.contentTypeId || current.contentType?.slug !== expected.contentType?.slug || (current.authorId ?? void 0) !== (expected.authorId ?? void 0) || current.slug !== expected.slug || current.data !== expected.data || current.updatedAt.getTime() !== expected.updatedAt.getTime()) {
+  if (current.id !== expected.id || current.contentTypeId !== expected.contentTypeId || current.contentType?.slug !== expected.contentType?.slug || (current.authorId ?? void 0) !== (expected.authorId ?? void 0) || current.slug !== expected.slug || current.data !== expected.data || current.publishAt?.getTime() !== expected.publishAt?.getTime() || current.updatedAt.getTime() !== expected.updatedAt.getTime()) {
     throw staleRecordError();
   }
 }
@@ -399,8 +418,10 @@ async function applyRelationWritePlan(adapter, plan) {
     if (existing) throw staleRecordError();
     await adapter.create({
       model: "contentItem",
-      data: item
+      data: item,
+      forceAllowId: true
     });
+    await recordContentRevision(adapter, item, item.authorId);
   }
 }
 function relationFilterSnapshot(sourceContentType, fieldName, relation, targetContentType) {
@@ -636,6 +657,7 @@ async function deriveInverseSourceAuthorization(adapter, ensureSynced, targetTyp
 }
 function createCMSOperations(adapter, options) {
   const { ensureSynced, getContentTypesWithCounts, hooks } = options;
+  const publicationFor = (typeSlug, view) => view === "content" ? options.contentTypes?.find((type) => type.slug === typeSlug)?.publication : void 0;
   const populatedRelationSnapshots = /* @__PURE__ */ new WeakMap();
   const relationWriteAuthorizationSnapshots = /* @__PURE__ */ new WeakMap();
   const relationFilterAuthorizationSnapshots = /* @__PURE__ */ new WeakMap();
@@ -887,7 +909,10 @@ function createCMSOperations(adapter, options) {
         input.typeSlug
       );
       if (!input.query.slug) {
-        return collectionFacts(contentType.slug);
+        return collectionFacts(
+          contentType.slug,
+          publicationFor(contentType.slug, input.query.view) ? "content" : void 0
+        );
       }
       const item = await getContentItemBySlug(
         adapter,
@@ -896,6 +921,7 @@ function createCMSOperations(adapter, options) {
       );
       const facts = {
         contentType: contentType.slug,
+        ...publicationFor(contentType.slug, input.query.view) ? { view: "content" } : {},
         scope: "record",
         ...item ? {
           recordId: item.id,
@@ -914,11 +940,16 @@ function createCMSOperations(adapter, options) {
           input.query
         );
       }
-      const result = await getAllContentItems(adapter, facts.contentType, {
-        ...input.query,
-        view: void 0,
-        fields: void 0
-      });
+      const result = await getAllContentItems(
+        adapter,
+        facts.contentType,
+        {
+          ...input.query,
+          view: void 0,
+          fields: void 0
+        },
+        publicationFor(facts.contentType, input.query.view)
+      );
       if (facts.scope === "record") {
         if (!facts.recordId) {
           if (result.items.length > 0) throw staleRecordError();
@@ -956,7 +987,8 @@ function createCMSOperations(adapter, options) {
     input: GetContentItemInputSchema,
     permission: cmsPermissions.record.read,
     facts: async ({ input }) => recordFacts(
-      await getRecordOrThrow(adapter, ensureSynced, input.typeSlug, input.id)
+      await getRecordOrThrow(adapter, ensureSynced, input.typeSlug, input.id),
+      publicationFor(input.typeSlug, input.view) ? "content" : void 0
     ),
     additionalPermissions: ({ facts }) => [
       cmsPermissions.contentType.read({ contentType: facts.contentType })
@@ -969,6 +1001,14 @@ function createCMSOperations(adapter, options) {
         facts.recordId ?? ""
       );
       assertRecordFacts(item, facts);
+      const publication = publicationFor(facts.contentType, input.view);
+      if (publication && !isPublishedContent(item, publication)) {
+        throw new CMSOperationError(
+          404,
+          "Content item not found",
+          "RECORD_NOT_FOUND"
+        );
+      }
       validateOperationContentReadOptions(item.contentType, input);
       return applyContentReadOptions(
         operationContentItem(serializeContentItemWithType(item)),
@@ -1093,12 +1133,14 @@ function createCMSOperations(adapter, options) {
             contentTypeId: contentType.id,
             slug,
             data: JSON.stringify(validatedData),
+            publishAt: context.input.body.publishAt ? new Date(context.input.body.publishAt) : null,
             ...context.identity ? { authorId: context.identity.id } : {},
             createdAt: /* @__PURE__ */ new Date(),
             updatedAt: /* @__PURE__ */ new Date()
           }
         });
         await syncRelations(tx, item.id, relationPlan.relationIds);
+        await recordContentRevision(tx, item, context.identity?.id);
         const joined = await getRecordOrThrow(
           tx,
           ensureSynced,
@@ -1120,68 +1162,103 @@ function createCMSOperations(adapter, options) {
       await notifyError(error, "create", createContext(context));
     }
   });
-  const updateContentItem = defineOperation({
-    input: UpdateContentItemInputSchema,
-    permission: cmsPermissions.record.update,
-    facts: async ({ input }) => {
-      const item = await getRecordOrThrow(
-        adapter,
-        ensureSynced,
-        input.typeSlug,
-        input.id
+  const executeUpdateContentItem = async (context, replaceData = false) => {
+    const lifecycleContext = updateContext(context);
+    const contentType = await getContentTypeOrThrow(
+      adapter,
+      ensureSynced,
+      context.facts.contentType
+    );
+    const rawSlug = context.input.body.slug;
+    const slug = rawSlug ? slugify(rawSlug) : void 0;
+    if (rawSlug && !slug) {
+      throw new CMSOperationError(
+        400,
+        "Invalid slug: must contain at least one alphanumeric character",
+        "INVALID_SLUG"
       );
-      const facts = recordFacts(item);
-      return {
-        contentType: facts.contentType,
-        recordId: facts.recordId ?? input.id,
-        ...facts.authorId ? { authorId: facts.authorId } : {}
-      };
-    },
-    additionalPermissions: async ({ input, facts }) => {
-      const contentTypePermission = cmsPermissions.contentType.read({
-        contentType: facts.contentType
+    }
+    const bodyData = context.input.body.data;
+    const relationAuthorization = bodyData ? await recheckRelationWriteAuthorization(
+      context.input,
+      contentType.slug,
+      bodyData
+    ) : void 0;
+    const authorizedRecord = await getRecordOrThrow(
+      adapter,
+      ensureSynced,
+      context.facts.contentType,
+      context.facts.recordId
+    );
+    assertRecordFacts(authorizedRecord, context.facts);
+    if (slug && slug !== authorizedRecord.slug) {
+      const duplicate = await adapter.findOne({
+        model: "contentItem",
+        where: [
+          {
+            field: "contentTypeId",
+            value: contentType.id,
+            operator: "eq"
+          },
+          { field: "slug", value: slug, operator: "eq" }
+        ]
       });
-      if (!input.body.data) return [contentTypePermission];
-      const authorization = await deriveRelationWriteAuthorization(
-        adapter,
-        await getContentTypeOrThrow(adapter, ensureSynced, facts.contentType),
-        input.body.data,
-        ensureSynced
-      );
-      relationWriteAuthorizationSnapshots.set(input, authorization);
-      return [contentTypePermission, ...authorization.permissions];
-    },
-    execute: async (context) => {
-      const lifecycleContext = updateContext(context);
-      const contentType = await getContentTypeOrThrow(
-        adapter,
-        ensureSynced,
-        context.facts.contentType
-      );
-      const rawSlug = context.input.body.slug;
-      const slug = rawSlug ? slugify(rawSlug) : void 0;
-      if (rawSlug && !slug) {
+      if (duplicate) {
         throw new CMSOperationError(
-          400,
-          "Invalid slug: must contain at least one alphanumeric character",
-          "INVALID_SLUG"
+          409,
+          "Content item with this slug already exists",
+          "DUPLICATE_SLUG"
         );
       }
-      const bodyData = context.input.body.data;
-      const relationAuthorization = bodyData ? await recheckRelationWriteAuthorization(
-        context.input,
-        contentType.slug,
-        bodyData
-      ) : void 0;
-      const authorizedRecord = await getRecordOrThrow(
-        adapter,
+    }
+    const relationPlan = bodyData ? await planRelationsInData(
+      adapter,
+      contentType,
+      bodyData,
+      ensureSynced,
+      context.identity?.id
+    ) : void 0;
+    const currentData = authorizedRecord.data ? JSON.parse(authorizedRecord.data) : {};
+    const validation = getContentTypeZodSchema(contentType).safeParse({
+      ...replaceData ? {} : currentData,
+      ...relationPlan?.processedData ?? {}
+    });
+    if (!validation.success) {
+      throw new CMSOperationError(
+        400,
+        "Validation failed",
+        "RECORD_VALIDATION_FAILED",
+        validation.error.issues
+      );
+    }
+    const mergedData = validation.data;
+    await runBeforeHook(
+      () => hooks?.onBeforeUpdateContent?.(
+        context.facts.recordId,
+        mergedData,
+        lifecycleContext
+      ),
+      "Update operation denied"
+    );
+    return adapter.transaction(async (tx) => {
+      if (bodyData && relationAuthorization) {
+        await assertCurrentRelationWriteAuthorization(
+          tx,
+          relationAuthorization,
+          contentType.slug,
+          bodyData
+        );
+      }
+      const current = await getRecordOrThrow(
+        tx,
         ensureSynced,
         context.facts.contentType,
         context.facts.recordId
       );
-      assertRecordFacts(authorizedRecord, context.facts);
-      if (slug && slug !== authorizedRecord.slug) {
-        const duplicate = await adapter.findOne({
+      assertRecordFacts(current, context.facts);
+      assertRecordSnapshot(current, authorizedRecord);
+      if (slug && slug !== current.slug) {
+        const duplicate = await tx.findOne({
           model: "contentItem",
           where: [
             {
@@ -1200,132 +1277,453 @@ function createCMSOperations(adapter, options) {
           );
         }
       }
-      const relationPlan = bodyData ? await planRelationsInData(
-        adapter,
-        contentType,
-        bodyData,
-        ensureSynced,
-        context.identity?.id
-      ) : void 0;
-      const currentData = authorizedRecord.data ? JSON.parse(authorizedRecord.data) : {};
-      const validation = getContentTypeZodSchema(contentType).safeParse({
-        ...currentData,
-        ...relationPlan?.processedData ?? {}
+      if (relationPlan) await applyRelationWritePlan(tx, relationPlan);
+      const update = {
+        updatedAt: new Date(
+          Math.max(Date.now(), current.updatedAt.getTime() + 1)
+        )
+      };
+      if (context.input.body.publishAt !== void 0) {
+        update.publishAt = context.input.body.publishAt ? new Date(context.input.body.publishAt) : null;
+      }
+      if (slug) update.slug = slug;
+      if (bodyData) update.data = JSON.stringify(mergedData);
+      const matched = await tx.updateMany({
+        model: "contentItem",
+        where: [
+          {
+            field: "id",
+            value: context.facts.recordId,
+            operator: "eq"
+          },
+          {
+            field: "contentTypeId",
+            value: contentType.id,
+            operator: "eq"
+          },
+          {
+            field: "authorId",
+            value: context.facts.authorId ?? null,
+            operator: "eq"
+          },
+          {
+            field: "updatedAt",
+            value: current.updatedAt,
+            operator: "eq"
+          }
+        ],
+        update
       });
-      if (!validation.success) {
-        throw new CMSOperationError(
-          400,
-          "Validation failed",
-          "RECORD_VALIDATION_FAILED",
-          validation.error.issues
-        );
+      if (!didUpdateContentItem(matched, context.facts.recordId)) {
+        throw staleRecordError();
       }
-      const mergedData = validation.data;
-      await runBeforeHook(
-        () => hooks?.onBeforeUpdateContent?.(
+      if (replaceData) {
+        await tx.deleteMany({
+          model: "contentRelation",
+          where: [{ field: "sourceId", value: current.id, operator: "eq" }]
+        });
+      }
+      if (relationPlan) {
+        await syncRelations(
+          tx,
           context.facts.recordId,
-          mergedData,
-          lifecycleContext
-        ),
-        "Update operation denied"
+          relationPlan.relationIds
+        );
+      }
+      const updated = await getRecordOrThrow(
+        tx,
+        ensureSynced,
+        context.facts.contentType,
+        context.facts.recordId
       );
-      return adapter.transaction(async (tx) => {
-        if (bodyData && relationAuthorization) {
-          await assertCurrentRelationWriteAuthorization(
-            tx,
-            relationAuthorization,
-            contentType.slug,
-            bodyData
+      await recordContentRevision(tx, updated, context.identity?.id);
+      return operationContentItem(serializeContentItemWithType(updated));
+    });
+  };
+  const authorizeUpdateRelations = async ({
+    input,
+    facts
+  }) => {
+    const contentTypePermission = cmsPermissions.contentType.read({
+      contentType: facts.contentType
+    });
+    if (!input.body.data) return [contentTypePermission];
+    const authorization = await deriveRelationWriteAuthorization(
+      adapter,
+      await getContentTypeOrThrow(adapter, ensureSynced, facts.contentType),
+      input.body.data,
+      ensureSynced
+    );
+    relationWriteAuthorizationSnapshots.set(input, authorization);
+    return [contentTypePermission, ...authorization.permissions];
+  };
+  const updateFacts = async ({
+    input
+  }) => {
+    const item = await getRecordOrThrow(
+      adapter,
+      ensureSynced,
+      input.typeSlug,
+      input.id
+    );
+    const facts = recordFacts(item);
+    return {
+      contentType: facts.contentType,
+      recordId: facts.recordId ?? input.id,
+      ...facts.authorId ? { authorId: facts.authorId } : {}
+    };
+  };
+  const afterUpdateContentItem = async (context) => {
+    const base = updateContext(context);
+    const afterUpdateContent = hooks?.onAfterUpdateContent;
+    await afterUpdateContent?.(
+      context.result,
+      Object.freeze({ ...base, result: context.result })
+    );
+  };
+  const updateContentItem = defineOperation({
+    input: UpdateContentItemInputSchema,
+    permission: cmsPermissions.record.update,
+    facts: updateFacts,
+    additionalPermissions: authorizeUpdateRelations,
+    execute: (context) => executeUpdateContentItem(context),
+    after: afterUpdateContentItem,
+    onError: async ({ error, ...context }) => {
+      await notifyError(error, "update", updateContext(context));
+    }
+  });
+  const dispatchDueContent = defineOperation({
+    input: z.object({
+      limit: z.number().int().min(1).max(100).default(20),
+      after: z.string().min(1).optional()
+    }),
+    permission: cmsPermissions.contentType.read,
+    facts: async ({ request }) => {
+      if (request)
+        throw new CMSOperationError(
+          403,
+          "Publication dispatch requires trusted execution",
+          "TRUSTED_OPERATION_REQUIRED"
+        );
+      if (adapter.id !== "memory" && typeof adapter.options?.adapterConfig.transaction !== "function") {
+        throw new CMSOperationError(
+          500,
+          "Publication requires an adapter with isolated transaction support",
+          "ATOMIC_TRANSACTION_REQUIRED"
+        );
+      }
+      await ensureSynced();
+      return {};
+    },
+    execute: async ({ input }) => {
+      const run = async () => {
+        const result = {
+          scanned: 0,
+          published: [],
+          skipped: [],
+          failures: [],
+          nextCursor: null
+        };
+        const now = /* @__PURE__ */ new Date();
+        const types = /* @__PURE__ */ new Map();
+        for (const definition of options.contentTypes ?? []) {
+          if (!definition.publication) continue;
+          const type = await getContentTypeOrThrow(
+            adapter,
+            ensureSynced,
+            definition.slug
           );
+          types.set(type.id, { type, policy: definition.publication });
         }
-        const current = await getRecordOrThrow(
-          tx,
-          ensureSynced,
-          context.facts.contentType,
-          context.facts.recordId
-        );
-        assertRecordFacts(current, context.facts);
-        assertRecordSnapshot(current, authorizedRecord);
-        if (slug && slug !== current.slug) {
-          const duplicate = await tx.findOne({
+        if (!types.size) return result;
+        const dueWhere = [
+          {
+            field: "contentTypeId",
+            value: [...types.keys()],
+            operator: "in"
+          },
+          { field: "publishAt", value: null, operator: "ne" },
+          { field: "publishAt", value: now, operator: "lte" }
+        ];
+        const memory = adapter.id === "memory" || adapter.options?.adapterConfig.adapterId === "memory";
+        let offset = 0;
+        if (memory && input.after) {
+          let upper = await adapter.count({
             model: "contentItem",
-            where: [
-              {
-                field: "contentTypeId",
-                value: contentType.id,
-                operator: "eq"
-              },
-              { field: "slug", value: slug, operator: "eq" }
-            ]
+            where: dueWhere
           });
-          if (duplicate) {
-            throw new CMSOperationError(
-              409,
-              "Content item with this slug already exists",
-              "DUPLICATE_SLUG"
-            );
+          while (offset < upper) {
+            const middle = Math.floor((offset + upper) / 2);
+            const [probe] = await adapter.findMany({
+              model: "contentItem",
+              where: dueWhere,
+              select: ["id"],
+              sortBy: { field: "id", direction: "asc" },
+              limit: 1,
+              offset: middle
+            });
+            if (probe && probe.id.localeCompare(input.after) <= 0)
+              offset = middle + 1;
+            else upper = middle;
           }
         }
-        if (relationPlan) await applyRelationWritePlan(tx, relationPlan);
-        const update = { updatedAt: /* @__PURE__ */ new Date() };
-        if (slug) update.slug = slug;
-        if (bodyData) update.data = JSON.stringify(mergedData);
-        const matched = await tx.updateMany({
+        const candidates = await adapter.findMany({
           model: "contentItem",
           where: [
-            {
-              field: "id",
-              value: context.facts.recordId,
-              operator: "eq"
-            },
-            {
-              field: "contentTypeId",
-              value: contentType.id,
-              operator: "eq"
-            },
-            {
-              field: "authorId",
-              value: context.facts.authorId ?? null,
-              operator: "eq"
-            },
-            {
-              field: "updatedAt",
-              value: current.updatedAt,
-              operator: "eq"
-            }
+            ...dueWhere,
+            ...!memory && input.after ? [{ field: "id", value: input.after, operator: "gt" }] : []
           ],
-          update
+          limit: input.limit,
+          offset,
+          sortBy: { field: "id", direction: "asc" }
         });
-        if (!didUpdateContentItem(matched, context.facts.recordId)) {
-          throw staleRecordError();
-        }
-        if (relationPlan) {
-          await syncRelations(
-            tx,
-            context.facts.recordId,
-            relationPlan.relationIds
-          );
+        result.nextCursor = candidates.length === input.limit ? candidates.at(-1).id : null;
+        for (const candidate of candidates) {
+          const { type, policy } = types.get(candidate.contentTypeId);
+          result.scanned += 1;
+          let committed = false;
+          let lifecycle;
+          try {
+            if (!candidate.publishAt || candidate.publishAt > now || JSON.parse(candidate.data)[policy.stateField] !== policy.scheduledValue) {
+              result.skipped.push(candidate.id);
+              continue;
+            }
+            const data = {
+              ...JSON.parse(candidate.data),
+              [policy.stateField]: policy.publishedValue
+            };
+            const context = {
+              input: {
+                typeSlug: type.slug,
+                id: candidate.id,
+                body: { data, publishAt: null }
+              },
+              facts: {
+                contentType: type.slug,
+                recordId: candidate.id,
+                ...candidate.authorId ? { authorId: candidate.authorId } : {}
+              },
+              identity: null
+            };
+            freezeCMSOperationData(context.input);
+            freezeCMSOperationData(context.facts);
+            lifecycle = context;
+            const validation = getContentTypeZodSchema(type).safeParse(data);
+            if (!validation.success)
+              throw new CMSOperationError(
+                400,
+                "Validation failed",
+                "RECORD_VALIDATION_FAILED",
+                validation.error.issues
+              );
+            await deriveRelationWriteAuthorization(
+              adapter,
+              type,
+              data,
+              ensureSynced
+            );
+            await runBeforeHook(
+              () => hooks?.onBeforeUpdateContent?.(
+                candidate.id,
+                validation.data,
+                updateContext(context)
+              ),
+              "Publication denied"
+            );
+            const item = await adapter.transaction(async (tx) => {
+              const current = await getRecordOrThrow(
+                tx,
+                ensureSynced,
+                type.slug,
+                candidate.id
+              );
+              assertRecordSnapshot(current, {
+                ...candidate,
+                contentType: type
+              });
+              await deriveRelationWriteAuthorization(
+                tx,
+                current.contentType,
+                data,
+                ensureSynced
+              );
+              const currentValidation = getContentTypeZodSchema(
+                current.contentType
+              ).safeParse(data);
+              if (!currentValidation.success)
+                throw new CMSOperationError(
+                  400,
+                  "Validation failed",
+                  "RECORD_VALIDATION_FAILED",
+                  currentValidation.error.issues
+                );
+              const matched = await tx.updateMany({
+                model: "contentItem",
+                where: [
+                  { field: "id", value: candidate.id, operator: "eq" },
+                  { field: "contentTypeId", value: type.id, operator: "eq" },
+                  { field: "data", value: candidate.data, operator: "eq" },
+                  {
+                    field: "publishAt",
+                    value: candidate.publishAt,
+                    operator: "eq"
+                  },
+                  {
+                    field: "updatedAt",
+                    value: candidate.updatedAt,
+                    operator: "eq"
+                  }
+                ],
+                update: {
+                  data: JSON.stringify(currentValidation.data),
+                  publishAt: null,
+                  updatedAt: new Date(
+                    Math.max(Date.now(), current.updatedAt.getTime() + 1)
+                  )
+                }
+              });
+              if (!didUpdateContentItem(matched, candidate.id))
+                throw staleRecordError();
+              const updated = await getRecordOrThrow(
+                tx,
+                ensureSynced,
+                type.slug,
+                candidate.id
+              );
+              await recordContentRevision(tx, updated);
+              return operationContentItem(
+                serializeContentItemWithType(updated)
+              );
+            });
+            committed = true;
+            freezeCMSOperationData(item);
+            result.published.push(candidate.id);
+            await afterUpdateContentItem({ ...context, result: item });
+            const afterPublish = hooks?.onAfterPublishContent;
+            await afterPublish?.(
+              item,
+              Object.freeze({ ...updateContext(context), result: item })
+            );
+          } catch (error) {
+            if (!committed && error instanceof CMSOperationError && (error.code === "RECORD_STATE_CHANGED" || error.code === "RECORD_NOT_FOUND")) {
+              result.skipped.push(candidate.id);
+            } else {
+              result.failures.push({
+                id: candidate.id,
+                message: normalizeOperationError(error, "Publication failed").message,
+                published: committed
+              });
+              if (lifecycle) {
+                try {
+                  await notifyError(error, "update", updateContext(lifecycle));
+                } catch {
+                }
+              }
+            }
+          }
         }
-        const updated = await getRecordOrThrow(
-          tx,
-          ensureSynced,
-          context.facts.contentType,
-          context.facts.recordId
+        return result;
+      };
+      const previous = dispatchQueues.get(adapter) ?? Promise.resolve();
+      const pending = previous.catch(() => {
+      }).then(run);
+      dispatchQueues.set(adapter, pending);
+      try {
+        return await pending;
+      } finally {
+        if (dispatchQueues.get(adapter) === pending)
+          dispatchQueues.delete(adapter);
+      }
+    }
+  });
+  const listContentRevisions = defineOperation({
+    input: CMSContentItemParamsSchema.extend(CMSRevisionsQuerySchema.shape),
+    permission: cmsPermissions.record.read,
+    facts: async ({ input }) => recordFacts(
+      await getRecordOrThrow(adapter, ensureSynced, input.typeSlug, input.id)
+    ),
+    additionalPermissions: ({ facts }) => [
+      cmsPermissions.contentType.read({ contentType: facts.contentType })
+    ],
+    execute: async ({ input, facts }) => {
+      assertRecordFacts(
+        await getRecordOrThrow(adapter, ensureSynced, input.typeSlug, input.id),
+        facts
+      );
+      const where = [
+        { field: "contentItemId", value: input.id, operator: "eq" }
+      ];
+      const revisions = await adapter.findMany({
+        model: "contentRevision",
+        where,
+        sortBy: { field: "version", direction: "desc" },
+        limit: 20,
+        offset: input.offset
+      });
+      return {
+        items: revisions.map((revision) => ({
+          ...revision,
+          createdAt: revision.createdAt.toISOString(),
+          publishAt: revision.publishAt?.toISOString() ?? null
+        })),
+        total: await adapter.count({ model: "contentRevision", where })
+      };
+    },
+    onError: ({ error, ...context }) => notifyError(
+      error,
+      "list",
+      genericContext(context, context.facts.contentType)
+    )
+  });
+  const restoreInputs = /* @__PURE__ */ new WeakMap();
+  const restoreContentRevision = defineOperation({
+    input: CMSRevisionParamsSchema,
+    permission: cmsPermissions.record.update,
+    facts: updateFacts,
+    additionalPermissions: async ({ input, facts }) => {
+      const revision = await adapter.findOne({
+        model: "contentRevision",
+        where: [
+          { field: "id", value: input.revisionId, operator: "eq" },
+          { field: "contentItemId", value: input.id, operator: "eq" }
+        ]
+      });
+      if (!revision)
+        throw new CMSOperationError(
+          404,
+          "Revision not found",
+          "REVISION_NOT_FOUND"
         );
-        return operationContentItem(serializeContentItemWithType(updated));
+      const updateInput = UpdateContentItemInputSchema.parse({
+        typeSlug: input.typeSlug,
+        id: input.id,
+        body: {
+          slug: revision.slug,
+          data: JSON.parse(revision.data),
+          publishAt: revision.publishAt?.toISOString() ?? null
+        }
       });
+      freezeCMSOperationData(updateInput);
+      restoreInputs.set(input, updateInput);
+      return [
+        cmsPermissions.record.read({ ...facts, scope: "record" }),
+        ...await authorizeUpdateRelations({ input: updateInput, facts })
+      ];
     },
+    execute: async (context) => executeUpdateContentItem(
+      { ...context, input: restoreInputs.get(context.input) },
+      true
+    ),
     after: async (context) => {
-      const base = updateContext(context);
-      const afterUpdateContent = hooks?.onAfterUpdateContent;
-      await afterUpdateContent?.(
-        context.result,
-        Object.freeze({ ...base, result: context.result })
-      );
+      const input = restoreInputs.get(context.input);
+      restoreInputs.delete(context.input);
+      await afterUpdateContentItem({ ...context, input });
     },
-    onError: async ({ error, ...context }) => {
-      await notifyError(error, "update", updateContext(context));
-    }
+    onError: ({ error, ...context }) => notifyError(
+      error,
+      "update",
+      genericContext(context, context.facts.contentType)
+    )
   });
   const deleteContentItem = defineOperation({
     input: DeleteContentItemInputSchema,
@@ -1492,7 +1890,8 @@ function createCMSOperations(adapter, options) {
     input: ListContentByRelationInputSchema,
     permission: cmsPermissions.record.read,
     facts: async ({ input }) => collectionFacts(
-      (await getContentTypeOrThrow(adapter, ensureSynced, input.typeSlug)).slug
+      (await getContentTypeOrThrow(adapter, ensureSynced, input.typeSlug)).slug,
+      publicationFor(input.typeSlug, input.query.view) ? "content" : void 0
     ),
     additionalPermissions: async ({ input, facts }) => {
       const sourceContentType = await getContentTypeOrThrow(
@@ -1524,7 +1923,8 @@ function createCMSOperations(adapter, options) {
       const result = await getContentItemsByRelationForType(
         adapter,
         sourceContentType,
-        input.query
+        input.query,
+        publicationFor(facts.contentType, input.query.view)
       );
       return {
         ...result,
@@ -1661,7 +2061,10 @@ function createCMSOperations(adapter, options) {
         ensureSynced,
         input.sourceType
       );
-      return collectionFacts(sourceType.slug);
+      return collectionFacts(
+        sourceType.slug,
+        publicationFor(sourceType.slug, input.query.view) ? "content" : void 0
+      );
     },
     additionalPermissions: async ({ input, facts }) => {
       const authorization = await deriveInverseSourceAuthorization(
@@ -1726,7 +2129,8 @@ function createCMSOperations(adapter, options) {
             targetId: input.query.itemId,
             limit: input.query.limit,
             offset: input.query.offset
-          }
+          },
+          publicationFor(facts.contentType, input.query.view)
         );
         return {
           ...result,
@@ -1751,6 +2155,9 @@ function createCMSOperations(adapter, options) {
     getContentItem,
     createContentItem,
     updateContentItem,
+    dispatchDueContent,
+    listContentRevisions,
+    restoreContentRevision,
     deleteContentItem,
     getContentItemPopulated,
     listContentByRelation,
@@ -1759,4 +2166,4 @@ function createCMSOperations(adapter, options) {
   };
 }
 
-export { CMSContentItemParamsSchema, CMSContentTypeParamsSchema, CMSCreateContentItemBodySchema, CMSOperationError, CMSUpdateContentItemBodySchema, createCMSOperations };
+export { CMSContentItemParamsSchema, CMSContentTypeParamsSchema, CMSCreateContentItemBodySchema, CMSOperationError, CMSRevisionParamsSchema, CMSRevisionsQuerySchema, CMSUpdateContentItemBodySchema, createCMSOperations };