@strapi/content-releases 0.0.0-next.f698d55751345c4ca87477ef683475c1a68f310a → 0.0.0-next.f86041c89a8c1545c6437a881dc613e98bc52bd7

package/dist/server/services/validation.js

@@ -0,0 +1,91 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var utils = require('@strapi/utils');
+var constants = require('../constants.js');
+
+class AlreadyOnReleaseError extends utils.errors.ApplicationError {
+    constructor(message){
+        super(message);
+        this.name = 'AlreadyOnReleaseError';
+    }
+}
+const createReleaseValidationService = ({ strapi })=>({
+        async validateUniqueEntry (releaseId, releaseActionArgs) {
+            /**
+     * Asserting the type, otherwise TS complains: 'release.actions' is of type 'unknown', even though the types come through for non-populated fields...
+     * Possibly related to the comment on GetValues: https://github.com/strapi/strapi/blob/main/packages/core/types/src/modules/entity-service/result.ts
+     */ const release = await strapi.db.query(constants.RELEASE_MODEL_UID).findOne({
+                where: {
+                    id: releaseId
+                },
+                populate: {
+                    actions: true
+                }
+            });
+            if (!release) {
+                throw new utils.errors.NotFoundError(`No release found for id ${releaseId}`);
+            }
+            const isEntryInRelease = release.actions.some((action)=>action.entryDocumentId === releaseActionArgs.entryDocumentId && action.contentType === releaseActionArgs.contentType && (releaseActionArgs.locale ? action.locale === releaseActionArgs.locale : true));
+            if (isEntryInRelease) {
+                throw new AlreadyOnReleaseError(`Entry with documentId ${releaseActionArgs.entryDocumentId}${releaseActionArgs.locale ? `( ${releaseActionArgs.locale})` : ''} and contentType ${releaseActionArgs.contentType} already exists in release with id ${releaseId}`);
+            }
+        },
+        validateEntryData (contentTypeUid, entryDocumentId) {
+            const contentType = strapi.contentType(contentTypeUid);
+            if (!contentType) {
+                throw new utils.errors.NotFoundError(`No content type found for uid ${contentTypeUid}`);
+            }
+            if (!utils.contentTypes.hasDraftAndPublish(contentType)) {
+                throw new utils.errors.ValidationError(`Content type with uid ${contentTypeUid} does not have draftAndPublish enabled`);
+            }
+            if (contentType.kind === 'collectionType' && !entryDocumentId) {
+                throw new utils.errors.ValidationError('Document id is required for collection type');
+            }
+        },
+        async validatePendingReleasesLimit () {
+            // Use the maximum releases option if it exists, otherwise default to 3
+            const featureCfg = strapi.ee.features.get('cms-content-releases');
+            const maximumPendingReleases = typeof featureCfg === 'object' && featureCfg?.options?.maximumReleases || 3;
+            const [, pendingReleasesCount] = await strapi.db.query(constants.RELEASE_MODEL_UID).findWithCount({
+                filters: {
+                    releasedAt: {
+                        $null: true
+                    }
+                }
+            });
+            // Unlimited is a number that will never be reached like 9999
+            if (pendingReleasesCount >= maximumPendingReleases) {
+                throw new utils.errors.ValidationError('You have reached the maximum number of pending releases');
+            }
+        },
+        async validateUniqueNameForPendingRelease (name, id) {
+            const pendingReleases = await strapi.db.query(constants.RELEASE_MODEL_UID).findMany({
+                where: {
+                    releasedAt: {
+                        $null: true
+                    },
+                    name,
+                    ...id && {
+                        id: {
+                            $ne: id
+                        }
+                    }
+                }
+            });
+            const isNameUnique = pendingReleases.length === 0;
+            if (!isNameUnique) {
+                throw new utils.errors.ValidationError(`Release with name ${name} already exists`);
+            }
+        },
+        async validateScheduledAtIsLaterThanNow (scheduledAt) {
+            if (scheduledAt && new Date(scheduledAt) <= new Date()) {
+                throw new utils.errors.ValidationError('Scheduled at must be later than now');
+            }
+        }
+    });
+
+exports.AlreadyOnReleaseError = AlreadyOnReleaseError;
+exports.default = createReleaseValidationService;
+//# sourceMappingURL=validation.js.map

package/dist/server/services/validation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.js","sources":["../../../server/src/services/validation.ts"],"sourcesContent":["import { errors, contentTypes } from '@strapi/utils';\nimport type { Core, UID } from '@strapi/types';\nimport type { Release, CreateRelease, UpdateRelease } from '../../../shared/contracts/releases';\nimport type { CreateReleaseAction } from '../../../shared/contracts/release-actions';\nimport { RELEASE_MODEL_UID } from '../constants';\n\nexport class AlreadyOnReleaseError extends errors.ApplicationError<'AlreadyOnReleaseError'> {\n  constructor(message: string) {\n    super(message);\n    this.name = 'AlreadyOnReleaseError';\n  }\n}\n\nconst createReleaseValidationService = ({ strapi }: { strapi: Core.Strapi }) => ({\n  async validateUniqueEntry(\n    releaseId: CreateReleaseAction.Request['params']['releaseId'],\n    releaseActionArgs: CreateReleaseAction.Request['body']\n  ) {\n    /**\n     * Asserting the type, otherwise TS complains: 'release.actions' is of type 'unknown', even though the types come through for non-populated fields...\n     * Possibly related to the comment on GetValues: https://github.com/strapi/strapi/blob/main/packages/core/types/src/modules/entity-service/result.ts\n     */\n    const release = (await strapi.db.query(RELEASE_MODEL_UID).findOne({\n      where: {\n        id: releaseId,\n      },\n      populate: {\n        actions: true,\n      },\n    })) as Release | null;\n\n    if (!release) {\n      throw new errors.NotFoundError(`No release found for id ${releaseId}`);\n    }\n\n    const isEntryInRelease = release.actions.some(\n      (action) =>\n        action.entryDocumentId === releaseActionArgs.entryDocumentId &&\n        action.contentType === releaseActionArgs.contentType &&\n        (releaseActionArgs.locale ? action.locale === releaseActionArgs.locale : true)\n    );\n\n    if (isEntryInRelease) {\n      throw new AlreadyOnReleaseError(\n        `Entry with documentId ${releaseActionArgs.entryDocumentId}${releaseActionArgs.locale ? `( ${releaseActionArgs.locale})` : ''} and contentType ${releaseActionArgs.contentType} already exists in release with id ${releaseId}`\n      );\n    }\n  },\n  validateEntryData(\n    contentTypeUid: CreateReleaseAction.Request['body']['contentType'],\n    entryDocumentId: CreateReleaseAction.Request['body']['entryDocumentId']\n  ) {\n    const contentType = strapi.contentType(contentTypeUid as UID.ContentType);\n\n    if (!contentType) {\n      throw new errors.NotFoundError(`No content type found for uid ${contentTypeUid}`);\n    }\n\n    if (!contentTypes.hasDraftAndPublish(contentType)) {\n      throw new errors.ValidationError(\n        `Content type with uid ${contentTypeUid} does not have draftAndPublish enabled`\n      );\n    }\n\n    if (contentType.kind === 'collectionType' && !entryDocumentId) {\n      throw new errors.ValidationError('Document id is required for collection type');\n    }\n  },\n  async validatePendingReleasesLimit() {\n    // Use the maximum releases option if it exists, otherwise default to 3\n    const featureCfg = strapi.ee.features.get('cms-content-releases');\n\n    const maximumPendingReleases =\n      (typeof featureCfg === 'object' && featureCfg?.options?.maximumReleases) || 3;\n\n    const [, pendingReleasesCount] = await strapi.db.query(RELEASE_MODEL_UID).findWithCount({\n      filters: {\n        releasedAt: {\n          $null: true,\n        },\n      },\n    });\n\n    // Unlimited is a number that will never be reached like 9999\n    if (pendingReleasesCount >= maximumPendingReleases) {\n      throw new errors.ValidationError('You have reached the maximum number of pending releases');\n    }\n  },\n  async validateUniqueNameForPendingRelease(\n    name: CreateRelease.Request['body']['name'],\n    id?: UpdateRelease.Request['params']['id']\n  ) {\n    const pendingReleases = (await strapi.db.query(RELEASE_MODEL_UID).findMany({\n      where: {\n        releasedAt: {\n          $null: true,\n        },\n        name,\n        ...(id && { id: { $ne: id } }),\n      },\n    })) as Release[];\n\n    const isNameUnique = pendingReleases.length === 0;\n\n    if (!isNameUnique) {\n      throw new errors.ValidationError(`Release with name ${name} already exists`);\n    }\n  },\n  async validateScheduledAtIsLaterThanNow(\n    scheduledAt: CreateRelease.Request['body']['scheduledAt']\n  ) {\n    if (scheduledAt && new Date(scheduledAt) <= new Date()) {\n      throw new errors.ValidationError('Scheduled at must be later than now');\n    }\n  },\n});\n\nexport default createReleaseValidationService;\n"],"names":["AlreadyOnReleaseError","errors","ApplicationError","message","name","createReleaseValidationService","strapi","validateUniqueEntry","releaseId","releaseActionArgs","release","db","query","RELEASE_MODEL_UID","findOne","where","id","populate","actions","NotFoundError","isEntryInRelease","some","action","entryDocumentId","contentType","locale","validateEntryData","contentTypeUid","contentTypes","hasDraftAndPublish","ValidationError","kind","validatePendingReleasesLimit","featureCfg","ee","features","get","maximumPendingReleases","options","maximumReleases","pendingReleasesCount","findWithCount","filters","releasedAt","$null","validateUniqueNameForPendingRelease","pendingReleases","findMany","$ne","isNameUnique","length","validateScheduledAtIsLaterThanNow","scheduledAt","Date"],"mappings":"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"}

package/dist/server/services/validation.mjs

@@ -0,0 +1,86 @@
+import { errors, contentTypes } from '@strapi/utils';
+import { RELEASE_MODEL_UID } from '../constants.mjs';
+
+class AlreadyOnReleaseError extends errors.ApplicationError {
+    constructor(message){
+        super(message);
+        this.name = 'AlreadyOnReleaseError';
+    }
+}
+const createReleaseValidationService = ({ strapi })=>({
+        async validateUniqueEntry (releaseId, releaseActionArgs) {
+            /**
+     * Asserting the type, otherwise TS complains: 'release.actions' is of type 'unknown', even though the types come through for non-populated fields...
+     * Possibly related to the comment on GetValues: https://github.com/strapi/strapi/blob/main/packages/core/types/src/modules/entity-service/result.ts
+     */ const release = await strapi.db.query(RELEASE_MODEL_UID).findOne({
+                where: {
+                    id: releaseId
+                },
+                populate: {
+                    actions: true
+                }
+            });
+            if (!release) {
+                throw new errors.NotFoundError(`No release found for id ${releaseId}`);
+            }
+            const isEntryInRelease = release.actions.some((action)=>action.entryDocumentId === releaseActionArgs.entryDocumentId && action.contentType === releaseActionArgs.contentType && (releaseActionArgs.locale ? action.locale === releaseActionArgs.locale : true));
+            if (isEntryInRelease) {
+                throw new AlreadyOnReleaseError(`Entry with documentId ${releaseActionArgs.entryDocumentId}${releaseActionArgs.locale ? `( ${releaseActionArgs.locale})` : ''} and contentType ${releaseActionArgs.contentType} already exists in release with id ${releaseId}`);
+            }
+        },
+        validateEntryData (contentTypeUid, entryDocumentId) {
+            const contentType = strapi.contentType(contentTypeUid);
+            if (!contentType) {
+                throw new errors.NotFoundError(`No content type found for uid ${contentTypeUid}`);
+            }
+            if (!contentTypes.hasDraftAndPublish(contentType)) {
+                throw new errors.ValidationError(`Content type with uid ${contentTypeUid} does not have draftAndPublish enabled`);
+            }
+            if (contentType.kind === 'collectionType' && !entryDocumentId) {
+                throw new errors.ValidationError('Document id is required for collection type');
+            }
+        },
+        async validatePendingReleasesLimit () {
+            // Use the maximum releases option if it exists, otherwise default to 3
+            const featureCfg = strapi.ee.features.get('cms-content-releases');
+            const maximumPendingReleases = typeof featureCfg === 'object' && featureCfg?.options?.maximumReleases || 3;
+            const [, pendingReleasesCount] = await strapi.db.query(RELEASE_MODEL_UID).findWithCount({
+                filters: {
+                    releasedAt: {
+                        $null: true
+                    }
+                }
+            });
+            // Unlimited is a number that will never be reached like 9999
+            if (pendingReleasesCount >= maximumPendingReleases) {
+                throw new errors.ValidationError('You have reached the maximum number of pending releases');
+            }
+        },
+        async validateUniqueNameForPendingRelease (name, id) {
+            const pendingReleases = await strapi.db.query(RELEASE_MODEL_UID).findMany({
+                where: {
+                    releasedAt: {
+                        $null: true
+                    },
+                    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) <= new Date()) {
+                throw new errors.ValidationError('Scheduled at must be later than now');
+            }
+        }
+    });
+
+export { AlreadyOnReleaseError, createReleaseValidationService as default };
+//# sourceMappingURL=validation.mjs.map

package/dist/server/services/validation.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.mjs","sources":["../../../server/src/services/validation.ts"],"sourcesContent":["import { errors, contentTypes } from '@strapi/utils';\nimport type { Core, UID } from '@strapi/types';\nimport type { Release, CreateRelease, UpdateRelease } from '../../../shared/contracts/releases';\nimport type { CreateReleaseAction } from '../../../shared/contracts/release-actions';\nimport { RELEASE_MODEL_UID } from '../constants';\n\nexport class AlreadyOnReleaseError extends errors.ApplicationError<'AlreadyOnReleaseError'> {\n  constructor(message: string) {\n    super(message);\n    this.name = 'AlreadyOnReleaseError';\n  }\n}\n\nconst createReleaseValidationService = ({ strapi }: { strapi: Core.Strapi }) => ({\n  async validateUniqueEntry(\n    releaseId: CreateReleaseAction.Request['params']['releaseId'],\n    releaseActionArgs: CreateReleaseAction.Request['body']\n  ) {\n    /**\n     * Asserting the type, otherwise TS complains: 'release.actions' is of type 'unknown', even though the types come through for non-populated fields...\n     * Possibly related to the comment on GetValues: https://github.com/strapi/strapi/blob/main/packages/core/types/src/modules/entity-service/result.ts\n     */\n    const release = (await strapi.db.query(RELEASE_MODEL_UID).findOne({\n      where: {\n        id: releaseId,\n      },\n      populate: {\n        actions: true,\n      },\n    })) as Release | null;\n\n    if (!release) {\n      throw new errors.NotFoundError(`No release found for id ${releaseId}`);\n    }\n\n    const isEntryInRelease = release.actions.some(\n      (action) =>\n        action.entryDocumentId === releaseActionArgs.entryDocumentId &&\n        action.contentType === releaseActionArgs.contentType &&\n        (releaseActionArgs.locale ? action.locale === releaseActionArgs.locale : true)\n    );\n\n    if (isEntryInRelease) {\n      throw new AlreadyOnReleaseError(\n        `Entry with documentId ${releaseActionArgs.entryDocumentId}${releaseActionArgs.locale ? `( ${releaseActionArgs.locale})` : ''} and contentType ${releaseActionArgs.contentType} already exists in release with id ${releaseId}`\n      );\n    }\n  },\n  validateEntryData(\n    contentTypeUid: CreateReleaseAction.Request['body']['contentType'],\n    entryDocumentId: CreateReleaseAction.Request['body']['entryDocumentId']\n  ) {\n    const contentType = strapi.contentType(contentTypeUid as UID.ContentType);\n\n    if (!contentType) {\n      throw new errors.NotFoundError(`No content type found for uid ${contentTypeUid}`);\n    }\n\n    if (!contentTypes.hasDraftAndPublish(contentType)) {\n      throw new errors.ValidationError(\n        `Content type with uid ${contentTypeUid} does not have draftAndPublish enabled`\n      );\n    }\n\n    if (contentType.kind === 'collectionType' && !entryDocumentId) {\n      throw new errors.ValidationError('Document id is required for collection type');\n    }\n  },\n  async validatePendingReleasesLimit() {\n    // Use the maximum releases option if it exists, otherwise default to 3\n    const featureCfg = strapi.ee.features.get('cms-content-releases');\n\n    const maximumPendingReleases =\n      (typeof featureCfg === 'object' && featureCfg?.options?.maximumReleases) || 3;\n\n    const [, pendingReleasesCount] = await strapi.db.query(RELEASE_MODEL_UID).findWithCount({\n      filters: {\n        releasedAt: {\n          $null: true,\n        },\n      },\n    });\n\n    // Unlimited is a number that will never be reached like 9999\n    if (pendingReleasesCount >= maximumPendingReleases) {\n      throw new errors.ValidationError('You have reached the maximum number of pending releases');\n    }\n  },\n  async validateUniqueNameForPendingRelease(\n    name: CreateRelease.Request['body']['name'],\n    id?: UpdateRelease.Request['params']['id']\n  ) {\n    const pendingReleases = (await strapi.db.query(RELEASE_MODEL_UID).findMany({\n      where: {\n        releasedAt: {\n          $null: true,\n        },\n        name,\n        ...(id && { id: { $ne: id } }),\n      },\n    })) as Release[];\n\n    const isNameUnique = pendingReleases.length === 0;\n\n    if (!isNameUnique) {\n      throw new errors.ValidationError(`Release with name ${name} already exists`);\n    }\n  },\n  async validateScheduledAtIsLaterThanNow(\n    scheduledAt: CreateRelease.Request['body']['scheduledAt']\n  ) {\n    if (scheduledAt && new Date(scheduledAt) <= new Date()) {\n      throw new errors.ValidationError('Scheduled at must be later than now');\n    }\n  },\n});\n\nexport default createReleaseValidationService;\n"],"names":["AlreadyOnReleaseError","errors","ApplicationError","message","name","createReleaseValidationService","strapi","validateUniqueEntry","releaseId","releaseActionArgs","release","db","query","RELEASE_MODEL_UID","findOne","where","id","populate","actions","NotFoundError","isEntryInRelease","some","action","entryDocumentId","contentType","locale","validateEntryData","contentTypeUid","contentTypes","hasDraftAndPublish","ValidationError","kind","validatePendingReleasesLimit","featureCfg","ee","features","get","maximumPendingReleases","options","maximumReleases","pendingReleasesCount","findWithCount","filters","releasedAt","$null","validateUniqueNameForPendingRelease","pendingReleases","findMany","$ne","isNameUnique","length","validateScheduledAtIsLaterThanNow","scheduledAt","Date"],"mappings":"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"}

package/dist/server/src/controllers/homepage.d.ts

@@ -0,0 +1,6 @@
+import type { GetUpcomingReleases } from '../../../shared/contracts/homepage';
+declare const homepageController: () => {
+    getUpcomingReleases(): Promise<GetUpcomingReleases.Response>;
+};
+export default homepageController;
+//# sourceMappingURL=homepage.d.ts.map

package/dist/server/src/controllers/homepage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"homepage.d.ts","sourceRoot":"","sources":["../../../../server/src/controllers/homepage.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oCAAoC,CAAC;AAE9E,QAAA,MAAM,kBAAkB;2BAIS,QAAQ,4BAA4B,CAAC;CAIrE,CAAC;AAEF,eAAe,kBAAkB,CAAC"}

package/dist/server/src/controllers/index.d.ts

@@ -1,5 +1,8 @@
 /// <reference types="koa" />
 export declare const controllers: {
+    homepage: () => {
+        getUpcomingReleases(): Promise<import("../../../shared/contracts/homepage").GetUpcomingReleases.Response>;
+    };
     release: {
         findByDocumentAttached(ctx: import("koa").Context): Promise<void>;
         findPage(ctx: import("koa").Context): Promise<void>;

package/dist/server/src/controllers/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../server/src/controllers/index.ts"],"names":[],"mappings":";AAIA,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;CAIvB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../server/src/controllers/index.ts"],"names":[],"mappings":";AAKA,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;CAKvB,CAAC"}

package/dist/server/src/destroy.d.ts

@@ -1,4 +1,4 @@
-import { Core } from '@strapi/types';
+import type { Core } from '@strapi/types';
 export declare const destroy: ({ strapi }: {
     strapi: Core.Strapi;
 }) => Promise<void>;

package/dist/server/src/destroy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"destroy.d.ts","sourceRoot":"","sources":["../../../server/src/destroy.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAKrC,eAAO,MAAM,OAAO,eAAsB;IAAE,MAAM,EAAE,KAAK,MAAM,CAAA;CAAE,kBAQhE,CAAC"}
+{"version":3,"file":"destroy.d.ts","sourceRoot":"","sources":["../../../server/src/destroy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAK1C,eAAO,MAAM,OAAO,eAAsB;IAAE,MAAM,EAAE,KAAK,MAAM,CAAA;CAAE,kBAQhE,CAAC"}

package/dist/server/src/index.d.ts

@@ -107,6 +107,11 @@ declare const _default: {
         };
     };
     services: {
+        homepage: ({ strapi }: {
+            strapi: import("@strapi/types/dist/core").Strapi;
+        }) => {
+            getUpcomingReleases(): Promise<import("../../shared/contracts/releases").Release[]>;
+        };
         release: ({ strapi }: {
             strapi: import("@strapi/types/dist/core").Strapi;
         }) => {
@@ -1914,10 +1919,10 @@ declare const _default: {
         scheduling: ({ strapi }: {
             strapi: import("@strapi/types/dist/core").Strapi;
         }) => {
-            set(releaseId: import("@strapi/types/dist/data").ID, scheduleDate: Date): Promise<Map<import("@strapi/types/dist/data").ID, import("node-schedule").Job>>;
-            cancel(releaseId: import("@strapi/types/dist/data").ID): Map<import("@strapi/types/dist/data").ID, import("node-schedule").Job>;
-            getAll(): Map<import("@strapi/types/dist/data").ID, import("node-schedule").Job>;
-            syncFromDatabase(): Promise<Map<import("@strapi/types/dist/data").ID, import("node-schedule").Job>>;
+            set(releaseId: import("@strapi/types/dist/data").ID, scheduleDate: Date): Promise<Map<import("@strapi/types/dist/data").ID, string>>;
+            cancel(releaseId: import("@strapi/types/dist/data").ID): Map<import("@strapi/types/dist/data").ID, string>;
+            getAll(): Map<import("@strapi/types/dist/data").ID, string>;
+            syncFromDatabase(): Promise<Map<import("@strapi/types/dist/data").ID, string>>;
         };
         settings: ({ strapi }: {
             strapi: import("@strapi/types/dist/core").Strapi;
@@ -1929,6 +1934,9 @@ declare const _default: {
         };
     };
     controllers: {
+        homepage: () => {
+            getUpcomingReleases(): Promise<import("../../shared/contracts/homepage").GetUpcomingReleases.Response>;
+        };
         release: {
             findByDocumentAttached(ctx: import("koa").Context): Promise<void>;
             findPage(ctx: import("koa").Context): Promise<void>;
@@ -1952,6 +1960,7 @@ declare const _default: {
         };
     };
     routes: {
+        homepage: import("@strapi/types/dist/core").Router;
         settings: {
             type: string;
             routes: {

package/dist/server/src/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../server/src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BA,wBAA2B"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../server/src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BA,wBAA2B"}

package/dist/server/src/middlewares/documents.d.ts

@@ -1,4 +1,4 @@
-import { Modules } from '@strapi/types';
+import type { Modules } from '@strapi/types';
 type Middleware = Modules.Documents.Middleware.Middleware;
 declare const deleteActionsOnDelete: Middleware;
 declare const updateActionsOnUpdate: Middleware;

package/dist/server/src/middlewares/documents.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"documents.d.ts","sourceRoot":"","sources":["../../../../server/src/middlewares/documents.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAO,MAAM,eAAe,CAAC;AAK7C,KAAK,UAAU,GAAG,OAAO,CAAC,SAAS,CAAC,UAAU,CAAC,UAAU,CAAC;AAyD1D,QAAA,MAAM,qBAAqB,EAAE,UA+B5B,CAAC;AAEF,QAAA,MAAM,qBAAqB,EAAE,UA0B5B,CAAC;AAEF,OAAO,EAAE,qBAAqB,EAAE,qBAAqB,EAAE,CAAC"}
+{"version":3,"file":"documents.d.ts","sourceRoot":"","sources":["../../../../server/src/middlewares/documents.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAO,MAAM,eAAe,CAAC;AAKlD,KAAK,UAAU,GAAG,OAAO,CAAC,SAAS,CAAC,UAAU,CAAC,UAAU,CAAC;AAyD1D,QAAA,MAAM,qBAAqB,EAAE,UA+B5B,CAAC;AAEF,QAAA,MAAM,qBAAqB,EAAE,UA0B5B,CAAC;AAEF,OAAO,EAAE,qBAAqB,EAAE,qBAAqB,EAAE,CAAC"}

package/dist/server/src/routes/homepage.d.ts

@@ -0,0 +1,4 @@
+import type { Plugin } from '@strapi/types';
+declare const homepageRouter: Plugin.LoadedPlugin['routes'][string];
+export default homepageRouter;
+//# sourceMappingURL=homepage.d.ts.map

package/dist/server/src/routes/homepage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"homepage.d.ts","sourceRoot":"","sources":["../../../../server/src/routes/homepage.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAI5C,QAAA,MAAM,cAAc,EAAE,MAAM,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC,MAAM,CAazD,CAAC;AAEF,eAAe,cAAc,CAAC"}

package/dist/server/src/routes/index.d.ts

@@ -1,4 +1,5 @@
 export declare const routes: {
+    homepage: import("@strapi/types/dist/core").Router;
     settings: {
         type: string;
         routes: {

package/dist/server/src/routes/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../server/src/routes/index.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAIlB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../server/src/routes/index.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAKlB,CAAC"}

package/dist/server/src/services/homepage.d.ts

@@ -0,0 +1,9 @@
+import type { Core } from '@strapi/types';
+import type { GetUpcomingReleases } from '../../../shared/contracts/homepage';
+declare const createHomepageService: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => {
+    getUpcomingReleases(): Promise<GetUpcomingReleases.Response['data']>;
+};
+export default createHomepageService;
+//# sourceMappingURL=homepage.d.ts.map

package/dist/server/src/services/homepage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"homepage.d.ts","sourceRoot":"","sources":["../../../../server/src/services/homepage.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAE1C,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oCAAoC,CAAC;AAE9E,QAAA,MAAM,qBAAqB,eAAgB;IAAE,MAAM,EAAE,KAAK,MAAM,CAAA;CAAE;2BAIjC,QAAQ,4BAA4B,CAAC,MAAM,CAAC,CAAC;CAc7E,CAAC;AAEF,eAAe,qBAAqB,CAAC"}

package/dist/server/src/services/index.d.ts

@@ -1,5 +1,10 @@
 /// <reference types="lodash" />
 export declare const services: {
+    homepage: ({ strapi }: {
+        strapi: import("@strapi/types/dist/core").Strapi;
+    }) => {
+        getUpcomingReleases(): Promise<import("../../../shared/contracts/releases").Release[]>;
+    };
     release: ({ strapi }: {
         strapi: import("@strapi/types/dist/core").Strapi;
     }) => {
@@ -1807,10 +1812,10 @@ export declare const services: {
     scheduling: ({ strapi }: {
         strapi: import("@strapi/types/dist/core").Strapi;
     }) => {
-        set(releaseId: import("@strapi/types/dist/data").ID, scheduleDate: Date): Promise<Map<import("@strapi/types/dist/data").ID, import("node-schedule").Job>>;
-        cancel(releaseId: import("@strapi/types/dist/data").ID): Map<import("@strapi/types/dist/data").ID, import("node-schedule").Job>;
-        getAll(): Map<import("@strapi/types/dist/data").ID, import("node-schedule").Job>;
-        syncFromDatabase(): Promise<Map<import("@strapi/types/dist/data").ID, import("node-schedule").Job>>;
+        set(releaseId: import("@strapi/types/dist/data").ID, scheduleDate: Date): Promise<Map<import("@strapi/types/dist/data").ID, string>>;
+        cancel(releaseId: import("@strapi/types/dist/data").ID): Map<import("@strapi/types/dist/data").ID, string>;
+        getAll(): Map<import("@strapi/types/dist/data").ID, string>;
+        syncFromDatabase(): Promise<Map<import("@strapi/types/dist/data").ID, string>>;
     };
     settings: ({ strapi }: {
         strapi: import("@strapi/types/dist/core").Strapi;

package/dist/server/src/services/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../server/src/services/index.ts"],"names":[],"mappings":";AAMA,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAMpB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../server/src/services/index.ts"],"names":[],"mappings":";AAOA,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAOpB,CAAC"}

package/dist/server/src/services/release-action.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"release-action.d.ts","sourceRoot":"","sources":["../../../../server/src/services/release-action.ts"],"names":[],"mappings":";AAEA,OAAO,KAAK,EAAE,IAAI,EAAY,OAAO,EAAE,GAAG,EAAQ,MAAM,eAAe,CAAC;AAIxE,OAAO,EAAE,wBAAwB,EAAqB,MAAM,cAAc,CAAC;AAE3E,OAAO,KAAK,EACV,mBAAmB,EACnB,iBAAiB,EACjB,aAAa,EACb,oBAAoB,EACpB,mBAAmB,EACnB,mBAAmB,EACpB,MAAM,2CAA2C,CAAC;AACnD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAgBpD,MAAM,WAAW,MAAO,SAAQ,MAAM;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd;AAMD,QAAA,MAAM,0BAA0B,eAAgB;IAAE,MAAM,EAAE,KAAK,MAAM,CAAA;CAAE;sBAyCtD,2BAA2B,CAAC,QAAQ,CAAC,CAAC,WAAW,CAAC,UACrD,2BAA2B,CAAC,MAAM,CAAC,mCACH;QAAE,0BAA0B,CAAC,EAAE,OAAO,CAAA;KAAE;wBAoErE,yBAAyB,CAAC,QAAQ,CAAC,CAAC,WAAW,CAAC,UACnD,yBAAyB,CAAC,OAAO,CAAC;;;;;;;;;0BAsDhB,aAAa,EAAE,WAAW,oBAAoB;6CA6B3B,aAAa,EAAE;wBAsCrD,QAAQ,aAAa,CAAC,MAAM,KAAK,CAAC,+BAA+B,EAAE,SAAS,CAAC;qBAQ1E,2BAA2B,CAAC,QAAQ,CAAC,CAAC,UAAU,CAAC,aAChD,2BAA2B,CAAC,QAAQ,CAAC,CAAC,WAAW,CAAC,UACrD,2BAA2B,CAAC,MAAM,CAAC;qBAwDjC,2BAA2B,CAAC,QAAQ,CAAC,CAAC,UAAU,CAAC,aAChD,2BAA2B,CAAC,QAAQ,CAAC,CAAC,WAAW,CAAC;mDAyBV,IAAI,WAAW,EAAE;CAuDzE,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG,UAAU,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAEjF,eAAe,0BAA0B,CAAC"}
+{"version":3,"file":"release-action.d.ts","sourceRoot":"","sources":["../../../../server/src/services/release-action.ts"],"names":[],"mappings":";AAEA,OAAO,KAAK,EAAE,IAAI,EAAY,OAAO,EAAE,GAAG,EAAQ,MAAM,eAAe,CAAC;AAIxE,OAAO,EAAE,wBAAwB,EAAqB,MAAM,cAAc,CAAC;AAE3E,OAAO,KAAK,EACV,mBAAmB,EACnB,iBAAiB,EACjB,aAAa,EACb,oBAAoB,EACpB,mBAAmB,EACnB,mBAAmB,EACpB,MAAM,2CAA2C,CAAC;AACnD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAC;AAgBpD,MAAM,WAAW,MAAO,SAAQ,MAAM;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd;AAMD,QAAA,MAAM,0BAA0B,eAAgB;IAAE,MAAM,EAAE,KAAK,MAAM,CAAA;CAAE;sBAyCtD,2BAA2B,CAAC,QAAQ,CAAC,CAAC,WAAW,CAAC,UACrD,2BAA2B,CAAC,MAAM,CAAC,mCACH;QAAE,0BAA0B,CAAC,EAAE,OAAO,CAAA;KAAE;wBAoErE,yBAAyB,CAAC,QAAQ,CAAC,CAAC,WAAW,CAAC,UACnD,yBAAyB,CAAC,OAAO,CAAC;;;;;;;;;0BAsDhB,aAAa,EAAE,WAAW,oBAAoB;6CA6B3B,aAAa,EAAE;wBAuCrD,QAAQ,aAAa,CAAC,MAAM,KAAK,CAAC,+BAA+B,EAAE,SAAS,CAAC;qBAQ1E,2BAA2B,CAAC,QAAQ,CAAC,CAAC,UAAU,CAAC,aAChD,2BAA2B,CAAC,QAAQ,CAAC,CAAC,WAAW,CAAC,UACrD,2BAA2B,CAAC,MAAM,CAAC;qBAwDjC,2BAA2B,CAAC,QAAQ,CAAC,CAAC,UAAU,CAAC,aAChD,2BAA2B,CAAC,QAAQ,CAAC,CAAC,WAAW,CAAC;mDAyBV,IAAI,WAAW,EAAE;CAuDzE,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG,UAAU,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAEjF,eAAe,0BAA0B,CAAC"}

package/dist/server/src/services/scheduling.d.ts

@@ -1,18 +1,17 @@
-import { Job } from 'node-schedule';
-import { Core } from '@strapi/types';
+import type { Core } from '@strapi/types';
 import { Release } from '../../../shared/contracts/releases';
 declare const createSchedulingService: ({ strapi }: {
     strapi: Core.Strapi;
 }) => {
-    set(releaseId: Release['id'], scheduleDate: Date): Promise<Map<import("@strapi/types/dist/data").ID, Job>>;
-    cancel(releaseId: Release['id']): Map<import("@strapi/types/dist/data").ID, Job>;
-    getAll(): Map<import("@strapi/types/dist/data").ID, Job>;
+    set(releaseId: Release['id'], scheduleDate: Date): Promise<Map<import("@strapi/types/dist/data").ID, string>>;
+    cancel(releaseId: Release['id']): Map<import("@strapi/types/dist/data").ID, string>;
+    getAll(): Map<import("@strapi/types/dist/data").ID, string>;
     /**
      * 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
      */
-    syncFromDatabase(): Promise<Map<import("@strapi/types/dist/data").ID, Job>>;
+    syncFromDatabase(): Promise<Map<import("@strapi/types/dist/data").ID, string>>;
 };
 export default createSchedulingService;
 //# sourceMappingURL=scheduling.d.ts.map

package/dist/server/src/services/scheduling.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scheduling.d.ts","sourceRoot":"","sources":["../../../../server/src/services/scheduling.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,GAAG,EAAE,MAAM,eAAe,CAAC;AACjD,OAAO,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAGrC,OAAO,EAAE,OAAO,EAAE,MAAM,oCAAoC,CAAC;AAI7D,QAAA,MAAM,uBAAuB,eAAgB;IAAE,MAAM,EAAE,KAAK,MAAM,CAAA;CAAE;mBAI3C,OAAO,CAAC,IAAI,CAAC,gBAAgB,IAAI;sBA6BpC,OAAO,CAAC,IAAI,CAAC;;IAa/B;;;;OAIG;;CAkBN,CAAC;AAEF,eAAe,uBAAuB,CAAC"}
+{"version":3,"file":"scheduling.d.ts","sourceRoot":"","sources":["../../../../server/src/services/scheduling.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAG1C,OAAO,EAAE,OAAO,EAAE,MAAM,oCAAoC,CAAC;AAI7D,QAAA,MAAM,uBAAuB,eAAgB;IAAE,MAAM,EAAE,KAAK,MAAM,CAAA;CAAE;mBAI3C,OAAO,CAAC,IAAI,CAAC,gBAAgB,IAAI;sBAkCpC,OAAO,CAAC,IAAI,CAAC;;IAa/B;;;;OAIG;;CAkBN,CAAC;AAEF,eAAe,uBAAuB,CAAC"}

package/dist/server/src/services/validation.d.ts

@@ -1,5 +1,5 @@
 import { errors } from '@strapi/utils';
-import { Core } from '@strapi/types';
+import type { Core } from '@strapi/types';
 import type { CreateRelease, UpdateRelease } from '../../../shared/contracts/releases';
 import type { CreateReleaseAction } from '../../../shared/contracts/release-actions';
 export declare class AlreadyOnReleaseError extends errors.ApplicationError<'AlreadyOnReleaseError'> {

package/dist/server/src/services/validation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../../../server/src/services/validation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAgB,MAAM,eAAe,CAAC;AACrD,OAAO,EAAE,IAAI,EAAO,MAAM,eAAe,CAAC;AAC1C,OAAO,KAAK,EAAW,aAAa,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAChG,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,2CAA2C,CAAC;AAGrF,qBAAa,qBAAsB,SAAQ,MAAM,CAAC,gBAAgB,CAAC,uBAAuB,CAAC;gBAC7E,OAAO,EAAE,MAAM;CAI5B;AAED,QAAA,MAAM,8BAA8B,eAAgB;IAAE,MAAM,EAAE,KAAK,MAAM,CAAA;CAAE;mCAE5D,2BAA2B,CAAC,QAAQ,CAAC,CAAC,WAAW,CAAC,qBAC1C,2BAA2B,CAAC,MAAM,CAAC;sCAiCtC,2BAA2B,CAAC,MAAM,CAAC,CAAC,aAAa,CAAC,mBACjD,2BAA2B,CAAC,MAAM,CAAC,CAAC,iBAAiB,CAAC;;8CAuCjE,qBAAqB,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,OACtC,qBAAqB,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC;mDAmB7B,qBAAqB,CAAC,MAAM,CAAC,CAAC,aAAa,CAAC;CAM3D,CAAC;AAEH,eAAe,8BAA8B,CAAC"}
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../../../server/src/services/validation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAgB,MAAM,eAAe,CAAC;AACrD,OAAO,KAAK,EAAE,IAAI,EAAO,MAAM,eAAe,CAAC;AAC/C,OAAO,KAAK,EAAW,aAAa,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAChG,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,2CAA2C,CAAC;AAGrF,qBAAa,qBAAsB,SAAQ,MAAM,CAAC,gBAAgB,CAAC,uBAAuB,CAAC;gBAC7E,OAAO,EAAE,MAAM;CAI5B;AAED,QAAA,MAAM,8BAA8B,eAAgB;IAAE,MAAM,EAAE,KAAK,MAAM,CAAA;CAAE;mCAE5D,2BAA2B,CAAC,QAAQ,CAAC,CAAC,WAAW,CAAC,qBAC1C,2BAA2B,CAAC,MAAM,CAAC;sCAiCtC,2BAA2B,CAAC,MAAM,CAAC,CAAC,aAAa,CAAC,mBACjD,2BAA2B,CAAC,MAAM,CAAC,CAAC,iBAAiB,CAAC;;8CAuCjE,qBAAqB,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,OACtC,qBAAqB,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC;mDAmB7B,qBAAqB,CAAC,MAAM,CAAC,CAAC,aAAa,CAAC;CAM3D,CAAC;AAEH,eAAe,8BAA8B,CAAC"}

package/dist/server/src/utils/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../server/src/utils/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAErD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAC5D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAC1D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AAEvE,KAAK,QAAQ,GAAG;IACd,OAAO,EAAE,cAAc,CAAC;IACxB,oBAAoB,EAAE,GAAG,CAAC;IAC1B,UAAU,EAAE,GAAG,CAAC;IAChB,gBAAgB,EAAE,oBAAoB,CAAC;IACvC,eAAe,EAAE,GAAG,CAAC;IACrB,QAAQ,EAAE,eAAe,CAAC;CAC3B,CAAC;AAEF,UAAU,MAAM;IACd,WAAW,EAAE,GAAG,CAAC,WAAW,CAAC;IAC7B,UAAU,CAAC,EAAE,IAAI,CAAC,UAAU,CAAC;IAC7B,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,eAAO,MAAM,UAAU,uCACf,KAAK,cACC;IAAE,MAAM,EAAE,KAAK,MAAM,CAAA;CAAE,KAClC,QAAQ,CAAC,KAAK,CAEhB,CAAC;AAEF,eAAO,MAAM,wBAAwB,wCACE,MAAM,cAC/B;IAAE,MAAM,EAAE,KAAK,MAAM,CAAA;CAAE,qBASpC,CAAC;AAEF,eAAO,MAAM,YAAY,mBACP,MAAM,SACf,GAAG,cACE;IAAE,MAAM,EAAE,KAAK,MAAM,CAAA;CAAE,qBAyBpC,CAAC;AAEF,eAAO,MAAM,QAAQ,2DAOhB,MAAM,GAAG;IAAE,MAAM,CAAC,EAAE,OAAO,GAAG,WAAW,CAAC;IAAC,QAAQ,EAAE,GAAG,CAAA;CAAE,cACjD;IAAE,MAAM,EAAE,KAAK,MAAM,CAAA;CAAE,+EAmBpC,CAAC;AAEF,eAAO,MAAM,cAAc,gBAAuB,IAAI,WAAW,SAAS,KAAK,WAAW,gDAwBzF,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../server/src/utils/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAErD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAC5D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAC1D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AAEvE,KAAK,QAAQ,GAAG;IACd,OAAO,EAAE,cAAc,CAAC;IACxB,oBAAoB,EAAE,GAAG,CAAC;IAC1B,UAAU,EAAE,GAAG,CAAC;IAChB,gBAAgB,EAAE,oBAAoB,CAAC;IACvC,eAAe,EAAE,GAAG,CAAC;IACrB,QAAQ,EAAE,eAAe,CAAC;CAC3B,CAAC;AAEF,UAAU,MAAM;IACd,WAAW,EAAE,GAAG,CAAC,WAAW,CAAC;IAC7B,UAAU,CAAC,EAAE,IAAI,CAAC,UAAU,CAAC;IAC7B,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,eAAO,MAAM,UAAU,uCACf,KAAK,cACC;IAAE,MAAM,EAAE,KAAK,MAAM,CAAA;CAAE,KAClC,QAAQ,CAAC,KAAK,CAEhB,CAAC;AAEF,eAAO,MAAM,wBAAwB,wCACE,MAAM,cAC/B;IAAE,MAAM,EAAE,KAAK,MAAM,CAAA;CAAE,qBASpC,CAAC;AAEF,eAAO,MAAM,YAAY,mBACP,MAAM,SACf,GAAG,cACE;IAAE,MAAM,EAAE,KAAK,MAAM,CAAA;CAAE,qBA0BpC,CAAC;AAEF,eAAO,MAAM,QAAQ,2DAOhB,MAAM,GAAG;IAAE,MAAM,CAAC,EAAE,OAAO,GAAG,WAAW,CAAC;IAAC,QAAQ,EAAE,GAAG,CAAA;CAAE,cACjD;IAAE,MAAM,EAAE,KAAK,MAAM,CAAA;CAAE,+EAmBpC,CAAC;AAEF,eAAO,MAAM,cAAc,gBAAuB,IAAI,WAAW,SAAS,KAAK,WAAW,gDAwBzF,CAAC"}

package/dist/server/utils/index.js

@@ -0,0 +1,94 @@
+'use strict';
+
+const getService = (name, { strapi: strapi1 })=>{
+    return strapi1.plugin('content-releases').service(name);
+};
+const getDraftEntryValidStatus = async ({ contentType, documentId, locale }, { strapi: strapi1 })=>{
+    const populateBuilderService = strapi1.plugin('content-manager').service('populate-builder');
+    // @ts-expect-error - populateBuilderService should be a function but is returning service
+    const populate = await populateBuilderService(contentType).populateDeep(Infinity).build();
+    const entry = await getEntry({
+        contentType,
+        documentId,
+        locale,
+        populate
+    }, {
+        strapi: strapi1
+    });
+    return isEntryValid(contentType, entry, {
+        strapi: strapi1
+    });
+};
+const isEntryValid = async (contentTypeUid, entry, { strapi: strapi1 })=>{
+    try {
+        // @TODO: When documents service has validateEntityCreation method, use it instead
+        await strapi1.entityValidator.validateEntityCreation(strapi1.getModel(contentTypeUid), entry, undefined, // @ts-expect-error - FIXME: entity here is unnecessary
+        entry);
+        const workflowsService = strapi1.plugin('review-workflows').service('workflows');
+        // Workflows service may not be available depending on the license
+        const workflow = await workflowsService?.getAssignedWorkflow(contentTypeUid, {
+            populate: 'stageRequiredToPublish'
+        });
+        if (workflow?.stageRequiredToPublish) {
+            return entry.strapi_stage.id === workflow.stageRequiredToPublish.id;
+        }
+        return true;
+    } catch  {
+        return false;
+    }
+};
+const getEntry = async ({ contentType, documentId, locale, populate, status = 'draft' }, { strapi: strapi1 })=>{
+    if (documentId) {
+        // Try to get an existing draft or published document
+        const entry = await strapi1.documents(contentType).findOne({
+            documentId,
+            locale,
+            populate,
+            status
+        });
+        // The document isn't published yet, but the action is to publish it, fetch the draft
+        if (status === 'published' && !entry) {
+            return strapi1.documents(contentType).findOne({
+                documentId,
+                locale,
+                populate,
+                status: 'draft'
+            });
+        }
+        return entry;
+    }
+    return strapi1.documents(contentType).findFirst({
+        locale,
+        populate,
+        status
+    });
+};
+const getEntryStatus = async (contentType, entry)=>{
+    if (entry.publishedAt) {
+        return 'published';
+    }
+    const publishedEntry = await strapi.documents(contentType).findOne({
+        documentId: entry.documentId,
+        locale: entry.locale,
+        status: 'published',
+        fields: [
+            'updatedAt'
+        ]
+    });
+    if (!publishedEntry) {
+        return 'draft';
+    }
+    const entryUpdatedAt = new Date(entry.updatedAt).getTime();
+    const publishedEntryUpdatedAt = new Date(publishedEntry.updatedAt).getTime();
+    if (entryUpdatedAt > publishedEntryUpdatedAt) {
+        return 'modified';
+    }
+    return 'published';
+};
+
+exports.getDraftEntryValidStatus = getDraftEntryValidStatus;
+exports.getEntry = getEntry;
+exports.getEntryStatus = getEntryStatus;
+exports.getService = getService;
+exports.isEntryValid = isEntryValid;
+//# sourceMappingURL=index.js.map

package/dist/server/utils/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../server/src/utils/index.ts"],"sourcesContent":["import type { UID, Data, Core } from '@strapi/types';\n\nimport type { SettingsService } from '../services/settings';\nimport type { ReleaseService } from '../services/release';\nimport type { ReleaseActionService } from '../services/release-action';\n\ntype Services = {\n  release: ReleaseService;\n  'release-validation': any;\n  scheduling: any;\n  'release-action': ReleaseActionService;\n  'event-manager': any;\n  settings: SettingsService;\n};\n\ninterface Action {\n  contentType: UID.ContentType;\n  documentId?: Data.DocumentID;\n  locale?: string;\n}\n\nexport const getService = <TName extends keyof Services>(\n  name: TName,\n  { strapi }: { strapi: Core.Strapi }\n): Services[TName] => {\n  return strapi.plugin('content-releases').service(name);\n};\n\nexport const getDraftEntryValidStatus = async (\n  { contentType, documentId, locale }: Action,\n  { strapi }: { strapi: Core.Strapi }\n) => {\n  const populateBuilderService = strapi.plugin('content-manager').service('populate-builder');\n  // @ts-expect-error - populateBuilderService should be a function but is returning service\n  const populate = await populateBuilderService(contentType).populateDeep(Infinity).build();\n\n  const entry = await getEntry({ contentType, documentId, locale, populate }, { strapi });\n\n  return isEntryValid(contentType, entry, { strapi });\n};\n\nexport const isEntryValid = async (\n  contentTypeUid: string,\n  entry: any,\n  { strapi }: { strapi: Core.Strapi }\n) => {\n  try {\n    // @TODO: When documents service has validateEntityCreation method, use it instead\n    await strapi.entityValidator.validateEntityCreation(\n      strapi.getModel(contentTypeUid as UID.ContentType),\n      entry,\n      undefined,\n      // @ts-expect-error - FIXME: entity here is unnecessary\n      entry\n    );\n\n    const workflowsService = strapi.plugin('review-workflows').service('workflows');\n    // Workflows service may not be available depending on the license\n    const workflow = await workflowsService?.getAssignedWorkflow(contentTypeUid, {\n      populate: 'stageRequiredToPublish',\n    });\n\n    if (workflow?.stageRequiredToPublish) {\n      return entry.strapi_stage.id === workflow.stageRequiredToPublish.id;\n    }\n\n    return true;\n  } catch {\n    return false;\n  }\n};\n\nexport const getEntry = async (\n  {\n    contentType,\n    documentId,\n    locale,\n    populate,\n    status = 'draft',\n  }: Action & { status?: 'draft' | 'published'; populate: any },\n  { strapi }: { strapi: Core.Strapi }\n) => {\n  if (documentId) {\n    // Try to get an existing draft or published document\n    const entry = await strapi\n      .documents(contentType)\n      .findOne({ documentId, locale, populate, status });\n\n    // The document isn't published yet, but the action is to publish it, fetch the draft\n    if (status === 'published' && !entry) {\n      return strapi\n        .documents(contentType)\n        .findOne({ documentId, locale, populate, status: 'draft' });\n    }\n\n    return entry;\n  }\n\n  return strapi.documents(contentType).findFirst({ locale, populate, status });\n};\n\nexport const getEntryStatus = async (contentType: UID.ContentType, entry: Data.ContentType) => {\n  if (entry.publishedAt) {\n    return 'published';\n  }\n\n  const publishedEntry = await strapi.documents(contentType).findOne({\n    documentId: entry.documentId,\n    locale: entry.locale,\n    status: 'published',\n    fields: ['updatedAt'],\n  });\n\n  if (!publishedEntry) {\n    return 'draft';\n  }\n\n  const entryUpdatedAt = new Date(entry.updatedAt).getTime();\n  const publishedEntryUpdatedAt = new Date(publishedEntry.updatedAt).getTime();\n\n  if (entryUpdatedAt > publishedEntryUpdatedAt) {\n    return 'modified';\n  }\n\n  return 'published';\n};\n"],"names":["getService","name","strapi","plugin","service","getDraftEntryValidStatus","contentType","documentId","locale","populateBuilderService","populate","populateDeep","Infinity","build","entry","getEntry","isEntryValid","contentTypeUid","entityValidator","validateEntityCreation","getModel","undefined","workflowsService","workflow","getAssignedWorkflow","stageRequiredToPublish","strapi_stage","id","status","documents","findOne","findFirst","getEntryStatus","publishedAt","publishedEntry","fields","entryUpdatedAt","Date","updatedAt","getTime","publishedEntryUpdatedAt"],"mappings":"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"}