@strapi/content-releases 0.0.0-next.6d59515520a3850456f256fb0e4c54b75054ddf4 → 0.0.0-next.aa7c7ec6724534e157d8a23fe85ee8318dabbf37

package/dist/server/index.mjs

@@ -2,6 +2,7 @@ import { contentTypes as contentTypes$1, mapAsync, setCreatorFields, errors, val
 import { difference, keys } from "lodash";
 import _ from "lodash/fp";
 import EE from "@strapi/strapi/dist/utils/ee";
+import { scheduleJob } from "node-schedule";
 import * as yup from "yup";
 const RELEASE_MODEL_UID = "plugin::content-releases.release";
 const RELEASE_ACTION_MODEL_UID = "plugin::content-releases.release-action";
@@ -83,6 +84,9 @@ const register = async ({ strapi: strapi2 }) => {
     strapi2.hook("strapi::content-types.afterSync").register(deleteActionsOnDeleteContentType);
   }
 };
+const getService = (name, { strapi: strapi2 } = { strapi: global.strapi }) => {
+  return strapi2.plugin("content-releases").service(name);
+};
 const { features: features$1 } = require("@strapi/strapi/dist/utils/ee");
 const bootstrap = async ({ strapi: strapi2 }) => {
   if (features$1.isEnabled("cms-content-releases")) {
@@ -130,6 +134,24 @@ const bootstrap = async ({ strapi: strapi2 }) => {
         }
       }
     });
+    if (strapi2.features.future.isEnabled("contentReleasesScheduling")) {
+      getService("scheduling", { strapi: strapi2 }).syncFromDatabase().catch((err) => {
+        strapi2.log.error(
+          "Error while syncing scheduled jobs from the database in the content-releases plugin. This could lead to errors in the releases scheduling."
+        );
+        throw err;
+      });
+    }
+  }
+};
+const destroy = async ({ strapi: strapi2 }) => {
+  if (strapi2.features.future.isEnabled("contentReleasesScheduling")) {
+    const scheduledJobs = getService("scheduling", {
+      strapi: strapi2
+    }).getAll();
+    for (const [, job] of scheduledJobs) {
+      job.cancel();
+    }
   }
 };
 const schema$1 = {
@@ -158,6 +180,9 @@ const schema$1 = {
     releasedAt: {
       type: "datetime"
     },
+    scheduledAt: {
+      type: "datetime"
+    },
     actions: {
       type: "relation",
       relation: "oneToMany",
@@ -220,9 +245,6 @@ const contentTypes = {
   release: release$1,
   "release-action": releaseAction$1
 };
-const getService = (name, { strapi: strapi2 } = { strapi: global.strapi }) => {
-  return strapi2.plugin("content-releases").service(name);
-};
 const getGroupName = (queryValue) => {
   switch (queryValue) {
     case "contentType":
@@ -238,17 +260,24 @@ const getGroupName = (queryValue) => {
 const createReleaseService = ({ strapi: strapi2 }) => ({
   async create(releaseData, { user }) {
     const releaseWithCreatorFields = await setCreatorFields({ user })(releaseData);
-    const { validatePendingReleasesLimit, validateUniqueNameForPendingRelease } = getService(
-      "release-validation",
-      { strapi: strapi2 }
-    );
+    const {
+      validatePendingReleasesLimit,
+      validateUniqueNameForPendingRelease,
+      validateScheduledAtIsLaterThanNow
+    } = getService("release-validation", { strapi: strapi2 });
     await Promise.all([
       validatePendingReleasesLimit(),
-      validateUniqueNameForPendingRelease(releaseWithCreatorFields.name)
+      validateUniqueNameForPendingRelease(releaseWithCreatorFields.name),
+      validateScheduledAtIsLaterThanNow(releaseWithCreatorFields.scheduledAt)
     ]);
-    return strapi2.entityService.create(RELEASE_MODEL_UID, {
+    const release2 = await strapi2.entityService.create(RELEASE_MODEL_UID, {
       data: releaseWithCreatorFields
     });
+    if (strapi2.features.future.isEnabled("contentReleasesScheduling") && releaseWithCreatorFields.scheduledAt) {
+      const schedulingService = getService("scheduling", { strapi: strapi2 });
+      await schedulingService.set(release2.id, release2.scheduledAt);
+    }
+    return release2;
   },
   async findOne(id, query = {}) {
     const release2 = await strapi2.entityService.findOne(RELEASE_MODEL_UID, id, {
@@ -343,6 +372,14 @@ const createReleaseService = ({ strapi: strapi2 }) => ({
   },
   async update(id, releaseData, { user }) {
     const releaseWithCreatorFields = await setCreatorFields({ user, isEdition: true })(releaseData);
+    const { validateUniqueNameForPendingRelease, validateScheduledAtIsLaterThanNow } = getService(
+      "release-validation",
+      { strapi: strapi2 }
+    );
+    await Promise.all([
+      validateUniqueNameForPendingRelease(releaseWithCreatorFields.name, id),
+      validateScheduledAtIsLaterThanNow(releaseWithCreatorFields.scheduledAt)
+    ]);
     const release2 = await strapi2.entityService.findOne(RELEASE_MODEL_UID, id);
     if (!release2) {
       throw new errors.NotFoundError(`No release found for id ${id}`);
@@ -358,6 +395,14 @@ const createReleaseService = ({ strapi: strapi2 }) => ({
       // @ts-expect-error see above
       data: releaseWithCreatorFields
     });
+    if (strapi2.features.future.isEnabled("contentReleasesScheduling")) {
+      const schedulingService = getService("scheduling", { strapi: strapi2 });
+      if (releaseData.scheduledAt) {
+        await schedulingService.set(id, releaseData.scheduledAt);
+      } else if (release2.scheduledAt) {
+        schedulingService.cancel(id);
+      }
+    }
     return updatedRelease;
   },
   async createAction(releaseId, action) {
@@ -542,27 +587,53 @@ const createReleaseService = ({ strapi: strapi2 }) => ({
     if (releaseWithPopulatedActionEntries.actions.length === 0) {
       throw new errors.ValidationError("No entries to publish");
     }
-    const actions = {};
+    const collectionTypeActions = {};
+    const singleTypeActions = [];
     for (const action of releaseWithPopulatedActionEntries.actions) {
       const contentTypeUid = action.contentType;
-      if (!actions[contentTypeUid]) {
-        actions[contentTypeUid] = {
-          entriestoPublishIds: [],
-          entriesToUnpublishIds: []
-        };
-      }
-      if (action.type === "publish") {
-        actions[contentTypeUid].entriestoPublishIds.push(action.entry.id);
+      if (strapi2.contentTypes[contentTypeUid].kind === "collectionType") {
+        if (!collectionTypeActions[contentTypeUid]) {
+          collectionTypeActions[contentTypeUid] = {
+            entriestoPublishIds: [],
+            entriesToUnpublishIds: []
+          };
+        }
+        if (action.type === "publish") {
+          collectionTypeActions[contentTypeUid].entriestoPublishIds.push(action.entry.id);
+        } else {
+          collectionTypeActions[contentTypeUid].entriesToUnpublishIds.push(action.entry.id);
+        }
       } else {
-        actions[contentTypeUid].entriesToUnpublishIds.push(action.entry.id);
+        singleTypeActions.push({
+          uid: contentTypeUid,
+          action: action.type,
+          id: action.entry.id
+        });
       }
     }
     const entityManagerService = strapi2.plugin("content-manager").service("entity-manager");
     const populateBuilderService = strapi2.plugin("content-manager").service("populate-builder");
     await strapi2.db.transaction(async () => {
-      for (const contentTypeUid of Object.keys(actions)) {
+      for (const { uid, action, id } of singleTypeActions) {
+        const populate = await populateBuilderService(uid).populateDeep(Infinity).build();
+        const entry = await strapi2.entityService.findOne(uid, id, { populate });
+        try {
+          if (action === "publish") {
+            await entityManagerService.publish(entry, uid);
+          } else {
+            await entityManagerService.unpublish(entry, uid);
+          }
+        } catch (error) {
+          if (error instanceof errors.ApplicationError && (error.message === "already.published" || error.message === "already.draft"))
+            ;
+          else {
+            throw error;
+          }
+        }
+      }
+      for (const contentTypeUid of Object.keys(collectionTypeActions)) {
         const populate = await populateBuilderService(contentTypeUid).populateDeep(Infinity).build();
-        const { entriestoPublishIds, entriesToUnpublishIds } = actions[contentTypeUid];
+        const { entriestoPublishIds, entriesToUnpublishIds } = collectionTypeActions[contentTypeUid];
         const entriesToPublish = await strapi2.entityService.findMany(
           contentTypeUid,
           {
@@ -688,27 +759,88 @@ const createReleaseValidationService = ({ strapi: strapi2 }) => ({
       throw new errors.ValidationError("You have reached the maximum number of pending releases");
     }
   },
-  async validateUniqueNameForPendingRelease(name) {
+  async validateUniqueNameForPendingRelease(name, id) {
     const pendingReleases = await strapi2.entityService.findMany(RELEASE_MODEL_UID, {
       filters: {
         releasedAt: {
           $null: true
         },
-        name
+        name,
+        ...id && { id: { $ne: id } }
       }
     });
     const isNameUnique = pendingReleases.length === 0;
     if (!isNameUnique) {
       throw new errors.ValidationError(`Release with name ${name} already exists`);
     }
+  },
+  async validateScheduledAtIsLaterThanNow(scheduledAt) {
+    if (scheduledAt && new Date(scheduledAt) <= /* @__PURE__ */ new Date()) {
+      throw new errors.ValidationError("Scheduled at must be later than now");
+    }
   }
 });
+const createSchedulingService = ({ strapi: strapi2 }) => {
+  const scheduledJobs = /* @__PURE__ */ new Map();
+  return {
+    async set(releaseId, scheduleDate) {
+      const release2 = await strapi2.db.query(RELEASE_MODEL_UID).findOne({ where: { id: releaseId, releasedAt: null } });
+      if (!release2) {
+        throw new errors.NotFoundError(`No release found for id ${releaseId}`);
+      }
+      const job = scheduleJob(scheduleDate, async () => {
+        try {
+          await getService("release").publish(releaseId);
+        } catch (error) {
+        }
+        this.cancel(releaseId);
+      });
+      if (scheduledJobs.has(releaseId)) {
+        this.cancel(releaseId);
+      }
+      scheduledJobs.set(releaseId, job);
+      return scheduledJobs;
+    },
+    cancel(releaseId) {
+      if (scheduledJobs.has(releaseId)) {
+        scheduledJobs.get(releaseId).cancel();
+        scheduledJobs.delete(releaseId);
+      }
+      return scheduledJobs;
+    },
+    getAll() {
+      return scheduledJobs;
+    },
+    /**
+     * On bootstrap, we can use this function to make sure to sync the scheduled jobs from the database that are not yet released
+     * This is useful in case the server was restarted and the scheduled jobs were lost
+     * This also could be used to sync different Strapi instances in case of a cluster
+     */
+    async syncFromDatabase() {
+      const releases = await strapi2.db.query(RELEASE_MODEL_UID).findMany({
+        where: {
+          scheduledAt: {
+            $gte: /* @__PURE__ */ new Date()
+          },
+          releasedAt: null
+        }
+      });
+      for (const release2 of releases) {
+        this.set(release2.id, release2.scheduledAt);
+      }
+      return scheduledJobs;
+    }
+  };
+};
 const services = {
   release: createReleaseService,
-  "release-validation": createReleaseValidationService
+  "release-validation": createReleaseValidationService,
+  ...strapi.features.future.isEnabled("contentReleasesScheduling") ? { scheduling: createSchedulingService } : {}
 };
 const RELEASE_SCHEMA = yup.object().shape({
-  name: yup.string().trim().required()
+  name: yup.string().trim().required(),
+  // scheduledAt is a date, but we always receive strings from the client
+  scheduledAt: yup.string().nullable()
 }).required().noUnknown();
 const validateRelease = validateYupSchema(RELEASE_SCHEMA);
 const releaseController = {
@@ -748,19 +880,18 @@ const releaseController = {
     const id = ctx.params.id;
     const releaseService = getService("release", { strapi });
     const release2 = await releaseService.findOne(id, { populate: ["createdBy"] });
-    const permissionsManager = strapi.admin.services.permission.createPermissionsManager({
-      ability: ctx.state.userAbility,
-      model: RELEASE_MODEL_UID
-    });
-    const sanitizedRelease = await permissionsManager.sanitizeOutput(release2);
+    if (!release2) {
+      throw new errors.NotFoundError(`Release not found for id: ${id}`);
+    }
     const count = await releaseService.countActions({
       filters: {
         release: id
       }
     });
-    if (!release2) {
-      throw new errors.NotFoundError(`Release not found for id: ${id}`);
-    }
+    const sanitizedRelease = {
+      ...release2,
+      createdBy: release2.createdBy ? strapi.admin.services.user.sanitizeUser(release2.createdBy) : null
+    };
     const data = {
       ...sanitizedRelease,
       actions: {
@@ -813,8 +944,27 @@ const releaseController = {
     const id = ctx.params.id;
     const releaseService = getService("release", { strapi });
     const release2 = await releaseService.publish(id, { user });
+    const [countPublishActions, countUnpublishActions] = await Promise.all([
+      releaseService.countActions({
+        filters: {
+          release: id,
+          type: "publish"
+        }
+      }),
+      releaseService.countActions({
+        filters: {
+          release: id,
+          type: "unpublish"
+        }
+      })
+    ]);
     ctx.body = {
-      data: release2
+      data: release2,
+      meta: {
+        totalEntries: countPublishActions + countUnpublishActions,
+        totalPublishedEntries: countPublishActions,
+        totalUnpublishedEntries: countUnpublishActions
+      }
     };
   }
 };
@@ -1086,6 +1236,7 @@ const getPlugin = () => {
     return {
       register,
       bootstrap,
+      destroy,
       contentTypes,
       services,
       controllers,