@akbarsafari00/bonyan-content-manager 5.52.1-fa.2

package/dist/server/services/document-manager.mjs

@@ -0,0 +1,235 @@
+import { omit, pipe } from 'lodash/fp';
+import { contentTypes, pagination } from '@strapi/utils';
+import { getDeepPopulateDraftCount, buildDeepPopulate, getDeepPopulate } from './utils/populate.mjs';
+import { EMPTY_DRAFT_RELATION_COUNTS } from './utils/draft-relations.mjs';
+import { sumDraftCounts } from './utils/draft.mjs';
+
+const { PUBLISHED_AT_ATTRIBUTE } = contentTypes.constants;
+const omitPublishedAtField = omit(PUBLISHED_AT_ATTRIBUTE);
+const omitIdField = omit('id');
+const documentManager = ({ strapi })=>{
+    return {
+        async findOne (id, uid, opts = {}) {
+            return strapi.documents(uid).findOne({
+                ...opts,
+                documentId: id
+            });
+        },
+        /**
+     * Find multiple (or all) locales for a document
+     */ async findLocales (id, uid, opts) {
+            // Will look for a specific locale by default
+            const where = {};
+            // Might not have an id if querying a single type
+            if (id) {
+                where.documentId = id;
+            }
+            // Search in array of locales
+            if (Array.isArray(opts.locale)) {
+                where.locale = {
+                    $in: opts.locale
+                };
+            } else if (opts.locale && opts.locale !== '*') {
+                // Look for a specific locale, ignore if looking for all locales
+                where.locale = opts.locale;
+            }
+            // Published is passed, so we filter on it, otherwise we don't filter
+            if (typeof opts.isPublished === 'boolean') {
+                where.publishedAt = {
+                    $notNull: opts.isPublished
+                };
+            }
+            return strapi.db.query(uid).findMany({
+                populate: opts.populate,
+                where
+            });
+        },
+        async findMany (opts, uid) {
+            const params = {
+                ...opts,
+                populate: getDeepPopulate(uid)
+            };
+            return strapi.documents(uid).findMany(params);
+        },
+        async findPage (opts, uid) {
+            const params = pagination.withDefaultPagination(opts || {}, {
+                maxLimit: 1000
+            });
+            const { populate: _populate, sort: _sort, ...countParams } = params;
+            const [documents, total = 0] = await Promise.all([
+                strapi.documents(uid).findMany(params),
+                strapi.documents(uid).count(countParams)
+            ]);
+            return {
+                results: documents,
+                pagination: pagination.transformPagedPaginationInfo(params, total)
+            };
+        },
+        async create (uid, opts = {}) {
+            const populate = opts.populate ?? await buildDeepPopulate(uid);
+            const params = {
+                ...opts,
+                status: 'draft',
+                populate
+            };
+            return strapi.documents(uid).create(params);
+        },
+        async update (id, uid, opts = {}) {
+            const publishData = pipe(omitPublishedAtField, omitIdField)(opts.data || {});
+            const populate = opts.populate ?? await buildDeepPopulate(uid);
+            const params = {
+                ...opts,
+                data: publishData,
+                populate,
+                status: 'draft'
+            };
+            return strapi.documents(uid).update({
+                ...params,
+                documentId: id
+            });
+        },
+        async clone (id, body, uid) {
+            const populate = await buildDeepPopulate(uid);
+            // Extract the locale to pass it as a plain param
+            const locale = body?.locale;
+            const params = {
+                // Ensure id and documentId are not copied to the clone
+                data: omit([
+                    'id',
+                    'documentId'
+                ], body),
+                locale,
+                populate
+            };
+            return strapi.documents(uid).clone({
+                ...params,
+                documentId: id
+            }).then((result)=>result?.entries.at(0));
+        },
+        /**
+     *  Check if a document exists
+     */ async exists (uid, id) {
+            // Collection type
+            if (id) {
+                const count = await strapi.db.query(uid).count({
+                    where: {
+                        documentId: id
+                    }
+                });
+                return count > 0;
+            }
+            // Single type
+            const count = await strapi.db.query(uid).count();
+            return count > 0;
+        },
+        async delete (id, uid, opts = {}) {
+            await strapi.documents(uid).delete({
+                ...opts,
+                documentId: id
+            });
+            return {};
+        },
+        // FIXME: handle relations
+        async deleteMany (documentIds, uid, opts = {}) {
+            const deletedEntries = await strapi.db.transaction(async ()=>{
+                return Promise.all(documentIds.map(async (id)=>this.delete(id, uid, opts)));
+            });
+            return {
+                count: deletedEntries.length
+            };
+        },
+        async publish (id, uid, opts = {}) {
+            const populate = opts.populate ?? await buildDeepPopulate(uid);
+            const params = {
+                ...opts,
+                populate
+            };
+            return strapi.documents(uid).publish({
+                ...params,
+                documentId: id
+            }).then((result)=>result?.entries);
+        },
+        async publishMany (uid, documentIds, locale) {
+            return strapi.db.transaction(async ()=>{
+                const results = await Promise.all(documentIds.map((documentId)=>this.publish(documentId, uid, {
+                        locale,
+                        populate: {}
+                    })));
+                const publishedEntitiesCount = results.flat().filter(Boolean).length;
+                return publishedEntitiesCount;
+            });
+        },
+        async unpublishMany (documentIds, uid, opts = {}) {
+            const unpublishedEntries = await strapi.db.transaction(async ()=>{
+                return Promise.all(documentIds.map((id)=>strapi.documents(uid).unpublish({
+                        ...opts,
+                        documentId: id,
+                        populate: {}
+                    }).then((result)=>result?.entries)));
+            });
+            const unpublishedEntitiesCount = unpublishedEntries.flat().filter(Boolean).length;
+            // Return the number of unpublished entities
+            return {
+                count: unpublishedEntitiesCount
+            };
+        },
+        async unpublish (id, uid, opts = {}) {
+            const populate = opts.populate ?? await buildDeepPopulate(uid);
+            const params = {
+                ...opts,
+                populate
+            };
+            return strapi.documents(uid).unpublish({
+                ...params,
+                documentId: id
+            }).then((result)=>result?.entries.at(0));
+        },
+        async discardDraft (id, uid, opts = {}) {
+            const populate = opts.populate ?? await buildDeepPopulate(uid);
+            const params = {
+                ...opts,
+                populate
+            };
+            return strapi.documents(uid).discardDraft({
+                ...params,
+                documentId: id
+            }).then((result)=>result?.entries.at(0));
+        },
+        async countDraftRelations (id, uid, locale) {
+            const { populate, hasRelations } = getDeepPopulateDraftCount(uid);
+            if (!hasRelations) {
+                return EMPTY_DRAFT_RELATION_COUNTS;
+            }
+            const document = await strapi.documents(uid).findOne({
+                documentId: id,
+                populate,
+                locale
+            });
+            if (!document) {
+                return EMPTY_DRAFT_RELATION_COUNTS;
+            }
+            return sumDraftCounts(strapi, document, uid);
+        },
+        async countManyEntriesDraftRelations (documentIds, uid, locale) {
+            const { populate, hasRelations } = getDeepPopulateDraftCount(uid);
+            if (!hasRelations) {
+                return 0;
+            }
+            const entities = await strapi.documents(uid).findMany({
+                populate,
+                filters: {
+                    documentId: {
+                        $in: documentIds
+                    }
+                },
+                locale,
+                status: 'draft'
+            });
+            const counts = await Promise.all(entities.map((entity)=>sumDraftCounts(strapi, entity, uid)));
+            return counts.reduce((total, entityCounts)=>total + entityCounts.unpublishedRelations + entityCounts.draftM2mLinks, 0);
+        }
+    };
+};
+
+export { documentManager as default };
+//# sourceMappingURL=document-manager.mjs.map

package/dist/server/services/document-manager.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"document-manager.mjs","sources":["../../../server/src/services/document-manager.ts"],"sourcesContent":["import { omit, pipe } from 'lodash/fp';\r\n\r\nimport { contentTypes, pagination } from '@strapi/utils';\r\nimport type { Core, Modules, UID } from '@strapi/types';\r\n\r\nimport { buildDeepPopulate, getDeepPopulate, getDeepPopulateDraftCount } from './utils/populate';\r\nimport { EMPTY_DRAFT_RELATION_COUNTS } from './utils/draft-relations';\r\nimport { sumDraftCounts } from './utils/draft';\r\n\r\ntype DocService = Modules.Documents.ServiceInstance;\r\ntype DocServiceParams<TAction extends keyof DocService> = Parameters<DocService[TAction]>[0];\r\nexport type Document = Modules.Documents.Result<UID.ContentType>;\r\n\r\nconst { PUBLISHED_AT_ATTRIBUTE } = contentTypes.constants;\r\n\r\nconst omitPublishedAtField = omit(PUBLISHED_AT_ATTRIBUTE);\r\nconst omitIdField = omit('id');\r\n\r\nconst documentManager = ({ strapi }: { strapi: Core.Strapi }) => {\r\n  return {\r\n    async findOne(\r\n      id: string,\r\n      uid: UID.CollectionType,\r\n      opts: Omit<DocServiceParams<'findOne'>, 'documentId'> = {}\r\n    ) {\r\n      return strapi.documents(uid).findOne({ ...opts, documentId: id });\r\n    },\r\n\r\n    /**\r\n     * Find multiple (or all) locales for a document\r\n     */\r\n    async findLocales(\r\n      id: string | string[] | undefined,\r\n      uid: UID.CollectionType,\r\n      opts: {\r\n        populate?: Modules.Documents.Params.Pick<any, 'populate'>;\r\n        locale?: string | string[] | '*';\r\n        isPublished?: boolean;\r\n      }\r\n    ) {\r\n      // Will look for a specific locale by default\r\n      const where: any = {};\r\n\r\n      // Might not have an id if querying a single type\r\n      if (id) {\r\n        where.documentId = id;\r\n      }\r\n\r\n      // Search in array of locales\r\n      if (Array.isArray(opts.locale)) {\r\n        where.locale = { $in: opts.locale };\r\n      } else if (opts.locale && opts.locale !== '*') {\r\n        // Look for a specific locale, ignore if looking for all locales\r\n        where.locale = opts.locale;\r\n      }\r\n\r\n      // Published is passed, so we filter on it, otherwise we don't filter\r\n      if (typeof opts.isPublished === 'boolean') {\r\n        where.publishedAt = { $notNull: opts.isPublished };\r\n      }\r\n\r\n      return strapi.db.query(uid).findMany({ populate: opts.populate, where });\r\n    },\r\n\r\n    async findMany(opts: DocServiceParams<'findMany'>, uid: UID.CollectionType) {\r\n      const params = { ...opts, populate: getDeepPopulate(uid) } as typeof opts;\r\n      return strapi.documents(uid).findMany(params);\r\n    },\r\n\r\n    async findPage(opts: DocServiceParams<'findMany'>, uid: UID.CollectionType) {\r\n      const params = pagination.withDefaultPagination(opts || {}, {\r\n        maxLimit: 1000,\r\n      });\r\n\r\n      const { populate: _populate, sort: _sort, ...countParams } = params;\r\n      const [documents, total = 0] = await Promise.all([\r\n        strapi.documents(uid).findMany(params),\r\n        strapi.documents(uid).count(countParams),\r\n      ]);\r\n\r\n      return {\r\n        results: documents,\r\n        pagination: pagination.transformPagedPaginationInfo(params, total),\r\n      };\r\n    },\r\n\r\n    async create(uid: UID.CollectionType, opts: DocServiceParams<'create'> = {} as any) {\r\n      const populate = opts.populate ?? (await buildDeepPopulate(uid));\r\n      const params = { ...opts, status: 'draft' as const, populate };\r\n\r\n      return strapi.documents(uid).create(params);\r\n    },\r\n\r\n    async update(\r\n      id: Modules.Documents.ID,\r\n      uid: UID.CollectionType,\r\n      opts: Omit<DocServiceParams<'update'>, 'documentId'> = {} as any\r\n    ) {\r\n      const publishData = pipe(omitPublishedAtField, omitIdField)(opts.data || {});\r\n      const populate = opts.populate ?? (await buildDeepPopulate(uid));\r\n      const params = { ...opts, data: publishData, populate, status: 'draft' };\r\n\r\n      return strapi.documents(uid).update({ ...params, documentId: id });\r\n    },\r\n\r\n    async clone(\r\n      id: Modules.Documents.ID,\r\n      body: Partial<Modules.Documents.Params.Data.Input<UID.CollectionType>>,\r\n      uid: UID.CollectionType\r\n    ) {\r\n      const populate = await buildDeepPopulate(uid);\r\n\r\n      // Extract the locale to pass it as a plain param\r\n      const locale = body?.locale;\r\n      const params = {\r\n        // Ensure id and documentId are not copied to the clone\r\n        data: omit(['id', 'documentId'], body),\r\n        locale,\r\n        populate,\r\n      };\r\n\r\n      return strapi\r\n        .documents(uid)\r\n        .clone({ ...params, documentId: id })\r\n        .then((result) => result?.entries.at(0));\r\n    },\r\n\r\n    /**\r\n     *  Check if a document exists\r\n     */\r\n    async exists(uid: UID.CollectionType, id?: string) {\r\n      // Collection type\r\n      if (id) {\r\n        const count = await strapi.db.query(uid).count({ where: { documentId: id } });\r\n        return count > 0;\r\n      }\r\n\r\n      // Single type\r\n      const count = await strapi.db.query(uid).count();\r\n      return count > 0;\r\n    },\r\n\r\n    async delete(\r\n      id: Modules.Documents.ID,\r\n      uid: UID.CollectionType,\r\n      opts: Omit<DocServiceParams<'delete'>, 'documentId'> = {} as any\r\n    ) {\r\n      await strapi.documents(uid).delete({\r\n        ...opts,\r\n        documentId: id,\r\n      });\r\n      return {};\r\n    },\r\n\r\n    // FIXME: handle relations\r\n    async deleteMany(\r\n      documentIds: Modules.Documents.ID[],\r\n      uid: UID.CollectionType,\r\n      opts: DocServiceParams<'findMany'> & { locale?: string } = {}\r\n    ) {\r\n      const deletedEntries = await strapi.db.transaction(async () => {\r\n        return Promise.all(documentIds.map(async (id) => this.delete(id, uid, opts)));\r\n      });\r\n\r\n      return { count: deletedEntries.length };\r\n    },\r\n\r\n    async publish(\r\n      id: Modules.Documents.ID,\r\n      uid: UID.CollectionType,\r\n      opts: Omit<DocServiceParams<'publish'>, 'documentId'> & { populate?: object } = {} as any\r\n    ) {\r\n      const populate = opts.populate ?? (await buildDeepPopulate(uid));\r\n      const params = { ...opts, populate };\r\n\r\n      return strapi\r\n        .documents(uid)\r\n        .publish({ ...params, documentId: id })\r\n        .then((result) => result?.entries);\r\n    },\r\n\r\n    async publishMany(uid: UID.ContentType, documentIds: string[], locale?: string | string[]) {\r\n      return strapi.db.transaction(async () => {\r\n        const results = await Promise.all(\r\n          documentIds.map((documentId) => this.publish(documentId, uid, { locale, populate: {} }))\r\n        );\r\n\r\n        const publishedEntitiesCount = results.flat().filter(Boolean).length;\r\n        return publishedEntitiesCount;\r\n      });\r\n    },\r\n\r\n    async unpublishMany(\r\n      documentIds: Modules.Documents.ID[],\r\n      uid: UID.CollectionType,\r\n      opts: Omit<DocServiceParams<'unpublish'>, 'documentId'> = {} as any\r\n    ) {\r\n      const unpublishedEntries = await strapi.db.transaction(async () => {\r\n        return Promise.all(\r\n          documentIds.map((id) =>\r\n            strapi\r\n              .documents(uid)\r\n              .unpublish({ ...opts, documentId: id, populate: {} })\r\n              .then((result) => result?.entries)\r\n          )\r\n        );\r\n      });\r\n\r\n      const unpublishedEntitiesCount = unpublishedEntries.flat().filter(Boolean).length;\r\n\r\n      // Return the number of unpublished entities\r\n      return { count: unpublishedEntitiesCount };\r\n    },\r\n\r\n    async unpublish(\r\n      id: Modules.Documents.ID,\r\n      uid: UID.CollectionType,\r\n      opts: Omit<DocServiceParams<'unpublish'>, 'documentId'> & { populate?: object } = {} as any\r\n    ) {\r\n      const populate = opts.populate ?? (await buildDeepPopulate(uid));\r\n      const params = { ...opts, populate };\r\n\r\n      return strapi\r\n        .documents(uid)\r\n        .unpublish({ ...params, documentId: id })\r\n        .then((result) => result?.entries.at(0));\r\n    },\r\n\r\n    async discardDraft(\r\n      id: Modules.Documents.ID,\r\n      uid: UID.CollectionType,\r\n      opts: Omit<DocServiceParams<'discardDraft'>, 'documentId'> & { populate?: object } = {} as any\r\n    ) {\r\n      const populate = opts.populate ?? (await buildDeepPopulate(uid));\r\n      const params = { ...opts, populate };\r\n\r\n      return strapi\r\n        .documents(uid)\r\n        .discardDraft({ ...params, documentId: id })\r\n        .then((result) => result?.entries.at(0));\r\n    },\r\n\r\n    async countDraftRelations(id: string, uid: UID.ContentType, locale: string) {\r\n      const { populate, hasRelations } = getDeepPopulateDraftCount(uid);\r\n\r\n      if (!hasRelations) {\r\n        return EMPTY_DRAFT_RELATION_COUNTS;\r\n      }\r\n\r\n      const document = await strapi.documents(uid).findOne({ documentId: id, populate, locale });\r\n      if (!document) {\r\n        return EMPTY_DRAFT_RELATION_COUNTS;\r\n      }\r\n\r\n      return sumDraftCounts(strapi, document, uid);\r\n    },\r\n\r\n    async countManyEntriesDraftRelations(\r\n      documentIds: Modules.Documents.ID[],\r\n      uid: UID.CollectionType,\r\n      locale: string | string[]\r\n    ) {\r\n      const { populate, hasRelations } = getDeepPopulateDraftCount(uid);\r\n\r\n      if (!hasRelations) {\r\n        return 0;\r\n      }\r\n\r\n      const entities = await strapi.documents(uid).findMany({\r\n        populate,\r\n        filters: { documentId: { $in: documentIds } } as any,\r\n        locale,\r\n        status: 'draft',\r\n      });\r\n\r\n      const counts = await Promise.all(\r\n        entities.map((entity: Document) => sumDraftCounts(strapi, entity, uid))\r\n      );\r\n\r\n      return counts.reduce(\r\n        (total, entityCounts) =>\r\n          total + entityCounts.unpublishedRelations + entityCounts.draftM2mLinks,\r\n        0\r\n      );\r\n    },\r\n  };\r\n};\r\n\r\nexport type DocumentManagerService = typeof documentManager;\r\n\r\nexport default documentManager;\r\n"],"names":["PUBLISHED_AT_ATTRIBUTE","contentTypes","constants","omitPublishedAtField","omit","omitIdField","documentManager","strapi","findOne","id","uid","opts","documents","documentId","findLocales","where","Array","isArray","locale","$in","isPublished","publishedAt","$notNull","db","query","findMany","populate","params","getDeepPopulate","findPage","pagination","withDefaultPagination","maxLimit","_populate","sort","_sort","countParams","total","Promise","all","count","results","transformPagedPaginationInfo","create","buildDeepPopulate","status","update","publishData","pipe","data","clone","body","then","result","entries","at","exists","delete","deleteMany","documentIds","deletedEntries","transaction","map","length","publish","publishMany","publishedEntitiesCount","flat","filter","Boolean","unpublishMany","unpublishedEntries","unpublish","unpublishedEntitiesCount","discardDraft","countDraftRelations","hasRelations","getDeepPopulateDraftCount","EMPTY_DRAFT_RELATION_COUNTS","document","sumDraftCounts","countManyEntriesDraftRelations","entities","filters","counts","entity","reduce","entityCounts","unpublishedRelations","draftM2mLinks"],"mappings":"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"}

package/dist/server/services/document-metadata.js

@@ -0,0 +1,368 @@
+'use strict';
+
+var fp = require('lodash/fp');
+var strapiUtils = require('@strapi/utils');
+
+const { getScalarAttributes, getMediaAttributes } = strapiUtils.contentTypes;
+// Scalar fields that can be used in a DB `select`
+const AVAILABLE_STATUS_SCALAR_FIELDS = [
+    'id',
+    'documentId',
+    'locale',
+    'updatedAt',
+    'createdAt',
+    'publishedAt'
+];
+// Relation populate shared by both the fast path and the full path
+const AVAILABLE_STATUS_POPULATE = {
+    createdBy: {
+        select: [
+            'id',
+            'firstname',
+            'lastname',
+            'email'
+        ]
+    },
+    updatedBy: {
+        select: [
+            'id',
+            'firstname',
+            'lastname',
+            'email'
+        ]
+    }
+};
+// All fields to pick from a hydrated result (scalars + populated relations + virtual)
+const AVAILABLE_STATUS_FIELDS = [
+    ...AVAILABLE_STATUS_SCALAR_FIELDS,
+    'createdBy',
+    'updatedBy',
+    'status'
+];
+const AVAILABLE_LOCALES_FIELDS = [
+    'id',
+    'documentId',
+    'locale',
+    'updatedAt',
+    'createdAt',
+    'publishedAt'
+];
+/** Returns a DB filter that matches the opposite publish status. */ const oppositePublishStatus = (publishedAt)=>publishedAt !== null ? {
+        $null: true
+    } : {
+        $notNull: true
+    };
+const CONTENT_MANAGER_STATUS = {
+    PUBLISHED: 'published',
+    DRAFT: 'draft',
+    MODIFIED: 'modified'
+};
+/**
+ * Checks if the provided document version has been modified after all other versions.
+ */ const getIsVersionLatestModification = (version, otherVersion)=>{
+    if (!version || !version.updatedAt) {
+        return false;
+    }
+    const versionUpdatedAt = version?.updatedAt ? new Date(version.updatedAt).getTime() : 0;
+    const otherUpdatedAt = otherVersion?.updatedAt ? new Date(otherVersion.updatedAt).getTime() : 0;
+    return versionUpdatedAt > otherUpdatedAt;
+};
+var documentMetadata = (({ strapi })=>({
+        /**
+   * Returns available locales of a document for the current status.
+   *
+   * The result is sorted with the default locale (as defined by the i18n plugin)
+   * at index 0 when present. This is the canonical-source invariant relied on by
+   * `useDocument.getInitialFormValues` in the admin: when creating a new locale
+   * draft, non-localized scalar/media values are inherited from
+   * `availableLocales[0]`. Putting the default locale first means inheritance
+   * stays predictable when sibling locales have drifted on non-localized fields
+   * (which can happen because the server only syncs non-localized fields at
+   * locale-creation time, not on subsequent updates — see
+   * `copyNonLocalizedFields` in document-service/internationalization.ts).
+   */ async getAvailableLocales (uid, version, allVersions) {
+            // Group all versions by locale
+            const versionsByLocale = fp.groupBy('locale', allVersions);
+            // Delete the current locale
+            if (version.locale) {
+                delete versionsByLocale[version.locale];
+            }
+            // For each locale, get the ones with the same status
+            // There will not be a draft and a version counterpart if the content
+            // type does not have draft and publish
+            const model = strapi.getModel(uid);
+            const mappingResult = await strapiUtils.async.map(Object.values(versionsByLocale), async (localeVersions)=>{
+                if (!strapiUtils.contentTypes.hasDraftAndPublish(model)) {
+                    return localeVersions[0];
+                }
+                const draftVersion = localeVersions.find((v)=>v.publishedAt === null);
+                const otherVersions = localeVersions.filter((v)=>v.id !== draftVersion?.id);
+                if (!draftVersion) {
+                    return;
+                }
+                return {
+                    ...draftVersion,
+                    status: this.getStatus(draftVersion, otherVersions)
+                };
+            });
+            const filtered = mappingResult.filter(Boolean);
+            // Sort the default locale first so `availableLocales[0]` is the canonical
+            // source for non-localized field inheritance in the admin. Guarded so that
+            // we no-op if the i18n plugin or its locales service is unavailable.
+            let defaultLocaleCode;
+            try {
+                defaultLocaleCode = await strapi.plugin('i18n')?.service('locales')?.getDefaultLocale();
+            } catch  {
+            // i18n plugin disabled or service errored — leave order untouched.
+            }
+            if (!defaultLocaleCode) {
+                return filtered;
+            }
+            // Stable partition: move the default locale entry to the front, keep the
+            // rest of the order intact.
+            const defaultEntries = filtered.filter((entry)=>entry.locale === defaultLocaleCode);
+            const otherEntries = filtered.filter((entry)=>entry.locale !== defaultLocaleCode);
+            return [
+                ...defaultEntries,
+                ...otherEntries
+            ];
+        },
+        /**
+   * Returns available status of a document for the current locale
+   */ getAvailableStatus (version, allVersions) {
+            // Find the other status of the document
+            const status = version.publishedAt !== null ? CONTENT_MANAGER_STATUS.DRAFT : CONTENT_MANAGER_STATUS.PUBLISHED;
+            // Get version that match the current locale and not match the current status
+            const availableStatus = allVersions.find((v)=>{
+                const matchLocale = v.locale === version.locale;
+                const matchStatus = status === 'published' ? v.publishedAt !== null : v.publishedAt === null;
+                return matchLocale && matchStatus;
+            });
+            if (!availableStatus) return availableStatus;
+            // Pick status fields (at fields, status, by fields), use lodash fp
+            return fp.pick(AVAILABLE_STATUS_FIELDS, availableStatus);
+        },
+        /**
+   * Get the available status of many documents, useful for batch operations
+   * @param uid
+   * @param documents
+   * @returns
+   */ async getManyAvailableStatus (uid, documents) {
+            if (!documents.length) return [];
+            // The status and locale of all documents should be the same
+            const status = documents[0].publishedAt !== null ? 'published' : 'draft';
+            const locales = documents.map((d)=>d.locale).filter(Boolean);
+            const where = {
+                documentId: {
+                    $in: documents.map((d)=>d.documentId).filter(Boolean)
+                },
+                publishedAt: {
+                    $null: status === 'published'
+                }
+            };
+            // If there is any locale to filter (if i18n is enabled)
+            if (locales.length === documents.length) {
+                where.locale = {
+                    $in: locales
+                };
+            } else if (locales.length) {
+                /*
+       * The batch mixes localized and non-localized versions, which happens when a
+       * content type holds rows with a locale while others have none — for instance
+       * after i18n is disabled on it, or when a locale is sent to a non-localized
+       * content type through the API.
+       *
+       * `locales` only holds the locales that are actually set, so filtering on it
+       * alone would drop the counterparts of every version whose locale is null, and
+       * those versions would be reported as drafts even though they are published.
+       */ where.$or = [
+                    {
+                        locale: {
+                            $in: locales
+                        }
+                    },
+                    {
+                        locale: {
+                            $null: true
+                        }
+                    }
+                ];
+            }
+            return strapi.query(uid).findMany({
+                where,
+                select: AVAILABLE_STATUS_SCALAR_FIELDS
+            });
+        },
+        getStatus (version, otherDocumentStatuses) {
+            let draftVersion;
+            let publishedVersion;
+            if (version.publishedAt) {
+                publishedVersion = version;
+            } else {
+                draftVersion = version;
+            }
+            const otherVersion = otherDocumentStatuses?.at(0);
+            if (otherVersion?.publishedAt) {
+                publishedVersion = otherVersion;
+            } else if (otherVersion) {
+                draftVersion = otherVersion;
+            }
+            if (!draftVersion) return CONTENT_MANAGER_STATUS.PUBLISHED;
+            if (!publishedVersion) return CONTENT_MANAGER_STATUS.DRAFT;
+            /*
+     * The document is modified if the draft version has been updated more
+     * recently than the published version.
+     */ const isDraftModified = getIsVersionLatestModification(draftVersion, publishedVersion);
+            return isDraftModified ? CONTENT_MANAGER_STATUS.MODIFIED : CONTENT_MANAGER_STATUS.PUBLISHED;
+        },
+        // TODO is it necessary to return metadata on every page of the CM
+        // We could refactor this so the locales are only loaded when they're
+        // needed. e.g. in the bulk locale action modal.
+        async getMetadata (uid, version, { availableLocales = true, availableStatus = true } = {}) {
+            const model = strapi.getModel(uid);
+            const hasDnP = strapiUtils.contentTypes.hasDraftAndPublish(model);
+            const isLocalized = model.pluginOptions?.i18n?.localized === true;
+            if (!availableLocales && !availableStatus) {
+                // Nothing to compute.
+                return {
+                    availableLocales: [],
+                    availableStatus: [],
+                    versions: []
+                };
+            }
+            if (!isLocalized && !hasDnP) {
+                // If there are no locales and no draft/publish, there's only ever 1 version of any document.
+                return {
+                    availableLocales: [],
+                    availableStatus: [],
+                    versions: []
+                };
+            }
+            const onlyStatusIsRelevant = hasDnP && (!isLocalized || !availableLocales);
+            if (onlyStatusIsRelevant) {
+                const otherVersion = availableStatus ? await strapi.db.query(uid).findOne({
+                    where: {
+                        documentId: version.documentId,
+                        ...version.locale ? {
+                            locale: version.locale
+                        } : {},
+                        publishedAt: oppositePublishStatus(version.publishedAt)
+                    },
+                    select: AVAILABLE_STATUS_SCALAR_FIELDS,
+                    populate: AVAILABLE_STATUS_POPULATE
+                }) : null;
+                return {
+                    availableLocales: [],
+                    availableStatus: otherVersion ? [
+                        fp.pick(AVAILABLE_STATUS_FIELDS, otherVersion)
+                    ] : [],
+                    versions: []
+                };
+            }
+            // Full path for localized content types
+            // TODO: Ignore publishedAt if availableStatus=false, and ignore locale if
+            // i18n is disabled
+            // Include non-translatable scalar and media fields in availableLocales for i18n prefilling
+            let nonLocalizedFields = [];
+            let nonLocalizedMediaFields = [];
+            try {
+                const i18nPlugin = strapi.plugin('i18n');
+                if (i18nPlugin) {
+                    const i18nService = i18nPlugin.service('content-types');
+                    if (i18nService?.getNonLocalizedAttributes) {
+                        if (model?.attributes) {
+                            const allNonLocalized = i18nService.getNonLocalizedAttributes(model);
+                            // Get scalar and media attributes separately
+                            const scalarAttrs = getScalarAttributes(model);
+                            const mediaAttrs = getMediaAttributes(model);
+                            // Separate scalar fields (can be in fields array) from media fields (need to be populated)
+                            nonLocalizedFields = allNonLocalized.filter((field)=>field in model.attributes && scalarAttrs.includes(field));
+                            nonLocalizedMediaFields = allNonLocalized.filter((field)=>field in model.attributes && mediaAttrs.includes(field));
+                        }
+                    }
+                }
+            } catch  {
+            // i18n plugin might not be enabled or might error, ignore silently
+            }
+            // Build populate object for non-localized media fields
+            const mediaPopulate = nonLocalizedMediaFields.reduce((acc, field)=>{
+                acc[field] = {
+                    populate: {
+                        folder: true
+                    }
+                };
+                return acc;
+            }, {});
+            const params = {
+                populate: {
+                    ...mediaPopulate,
+                    ...AVAILABLE_STATUS_POPULATE
+                },
+                fields: fp.uniq([
+                    ...AVAILABLE_LOCALES_FIELDS,
+                    ...nonLocalizedFields
+                ]),
+                filters: {
+                    documentId: version.documentId
+                }
+            };
+            const dbParams = strapi.get('query-params').transform(uid, params);
+            const versions = await strapi.db.query(uid).findMany(dbParams);
+            // TODO: Remove use of available locales and use localizations instead
+            const availableLocalesResult = availableLocales ? await this.getAvailableLocales(uid, version, versions) : [];
+            const availableStatusResult = availableStatus ? this.getAvailableStatus(version, versions) : null;
+            return {
+                availableLocales: availableLocalesResult,
+                availableStatus: availableStatusResult ? [
+                    availableStatusResult
+                ] : [],
+                versions
+            };
+        },
+        /**
+   * Returns associated metadata of a document:
+   * - Available locales of the document for the current status
+   * - Available status of the document for the current locale
+   */ async formatDocumentWithMetadata (uid, document, opts = {}) {
+            if (!document) {
+                return {
+                    data: document,
+                    meta: {
+                        availableLocales: [],
+                        availableStatus: []
+                    }
+                };
+            }
+            const hasDraftAndPublish = strapiUtils.contentTypes.hasDraftAndPublish(strapi.getModel(uid));
+            // Ignore available status if the content type does not have draft and publish
+            if (!hasDraftAndPublish) {
+                opts.availableStatus = false;
+            }
+            const { versions, ...meta } = await this.getMetadata(uid, document, opts);
+            // Populate localization statuses
+            if (document.localizations?.length) {
+                document.localizations = document.localizations.map((d)=>{
+                    // Find the counterpart version (same documentId + locale, opposite publishedAt) from
+                    // the already-fetched versions array, avoiding an extra DB query.
+                    const counterpart = versions.find((v)=>v.documentId === d.documentId && v.locale === d.locale && d.publishedAt === null !== (v.publishedAt === null));
+                    return {
+                        ...d,
+                        status: this.getStatus(d, counterpart ? [
+                            counterpart
+                        ] : [])
+                    };
+                });
+            }
+            return {
+                data: {
+                    ...document,
+                    // Add status to the document only if draft and publish is enabled
+                    status: hasDraftAndPublish ? this.getStatus(document, meta.availableStatus) : undefined
+                },
+                meta
+            };
+        }
+    }));
+
+module.exports = documentMetadata;
+//# sourceMappingURL=document-metadata.js.map