les-revisions 1.0.0

package/dist/server/index.js

@@ -0,0 +1,900 @@
+"use strict";
+const REVISION_UID$1 = "plugin::les-revisions.revision";
+const bootstrap = ({ strapi }) => {
+  strapi.documents.use(async (context, next) => {
+    const { action, uid } = context;
+    if (uid === REVISION_UID$1) return next();
+    const revisionService2 = strapi.plugin("les-revisions").service("revision");
+    if (!revisionService2.isEnabled(uid)) return next();
+    const requestCtx = strapi.requestContext?.get?.();
+    if (requestCtx?.state?._lesRevisionsSkip) return next();
+    const userId = requestCtx?.state?.user?.id ?? null;
+    if (action === "create") {
+      const result = await next();
+      try {
+        if (result?.documentId) {
+          const populated = await strapi.documents(uid).findOne({
+            documentId: result.documentId,
+            populate: revisionService2.getPopulate(uid)
+          });
+          await revisionService2.createRevision({
+            contentType: uid,
+            documentId: result.documentId,
+            snapshot: populated ?? result,
+            changeType: "create",
+            userId
+          });
+        }
+      } catch (error) {
+        strapi.log.error("[les-revisions] Failed to create revision on CREATE:", error);
+      }
+      return result;
+    }
+    if (action === "update") {
+      let previousState = null;
+      const docId = context.params?.documentId;
+      if (docId) {
+        try {
+          previousState = await strapi.documents(uid).findOne({
+            documentId: docId,
+            populate: revisionService2.getPopulate(uid)
+          });
+        } catch (error) {
+          strapi.log.warn("[les-revisions] Could not capture pre-update state:", error);
+        }
+      }
+      const result = await next();
+      if (previousState?.documentId) {
+        try {
+          await revisionService2.createRevision({
+            contentType: uid,
+            documentId: previousState.documentId,
+            snapshot: previousState,
+            changeType: "update",
+            userId
+          });
+        } catch (error) {
+          strapi.log.error("[les-revisions] Failed to create revision on UPDATE:", error);
+        }
+      }
+      return result;
+    }
+    if (action === "delete") {
+      let previousState = null;
+      const docId = context.params?.documentId;
+      if (docId) {
+        try {
+          previousState = await strapi.documents(uid).findOne({
+            documentId: docId,
+            populate: revisionService2.getPopulate(uid)
+          });
+        } catch (error) {
+          strapi.log.warn("[les-revisions] Could not capture pre-delete state:", error);
+        }
+      }
+      const result = await next();
+      if (previousState?.documentId) {
+        try {
+          await revisionService2.createRevision({
+            contentType: uid,
+            documentId: previousState.documentId,
+            snapshot: previousState,
+            changeType: "delete",
+            userId
+          });
+        } catch (error) {
+          strapi.log.error("[les-revisions] Failed to create revision on DELETE:", error);
+        }
+      }
+      return result;
+    }
+    return next();
+  });
+  strapi.log.info("[les-revisions] Versioning plugin bootstrapped");
+};
+const destroy = ({ strapi }) => {
+};
+const register = ({ strapi }) => {
+  strapi.log.info("[les-revisions] Plugin registered");
+};
+const config = {
+  default: {
+    maxVersions: 50,
+    enabledContentTypes: "*",
+    excludeContentTypes: [],
+    softDelete: true,
+    excludeFields: ["createdBy", "updatedBy"],
+    populateDepth: 3
+  },
+  validator(config2) {
+    if (config2.maxVersions !== void 0) {
+      if (typeof config2.maxVersions !== "number" || config2.maxVersions < 1) {
+        throw new Error("les-revisions: maxVersions must be a positive number");
+      }
+    }
+    if (config2.enabledContentTypes !== void 0 && config2.enabledContentTypes !== "*") {
+      if (!Array.isArray(config2.enabledContentTypes)) {
+        throw new Error('les-revisions: enabledContentTypes must be an array or "*"');
+      }
+    }
+    if (config2.excludeContentTypes !== void 0) {
+      if (!Array.isArray(config2.excludeContentTypes)) {
+        throw new Error("les-revisions: excludeContentTypes must be an array");
+      }
+    }
+    if (config2.softDelete !== void 0 && typeof config2.softDelete !== "boolean") {
+      throw new Error("les-revisions: softDelete must be a boolean");
+    }
+    if (config2.populateDepth !== void 0) {
+      if (typeof config2.populateDepth !== "number" || config2.populateDepth < 0) {
+        throw new Error("les-revisions: populateDepth must be a non-negative number");
+      }
+    }
+  }
+};
+const kind = "collectionType";
+const collectionName = "les_revisions";
+const info = {
+  singularName: "revision",
+  pluralName: "revisions",
+  displayName: "Revision",
+  description: "Stores versioned snapshots of content entries"
+};
+const options = {
+  draftAndPublish: false
+};
+const pluginOptions = {
+  "content-manager": {
+    visible: false
+  },
+  "content-type-builder": {
+    visible: false
+  }
+};
+const attributes = {
+  contentType: {
+    type: "string",
+    required: true,
+    configurable: false
+  },
+  entryDocumentId: {
+    type: "string",
+    required: true,
+    configurable: false
+  },
+  version: {
+    type: "integer",
+    required: true,
+    configurable: false,
+    "default": 1
+  },
+  snapshot: {
+    type: "json",
+    required: true,
+    configurable: false
+  },
+  changeType: {
+    type: "enumeration",
+    "enum": [
+      "create",
+      "update",
+      "delete"
+    ],
+    required: true,
+    configurable: false
+  },
+  changedByName: {
+    type: "string",
+    configurable: false
+  },
+  changedByEmail: {
+    type: "string",
+    configurable: false
+  },
+  changedById: {
+    type: "integer",
+    configurable: false
+  },
+  isDeleted: {
+    type: "boolean",
+    "default": false,
+    configurable: false
+  },
+  metadata: {
+    type: "json",
+    configurable: false
+  }
+};
+const schema = {
+  kind,
+  collectionName,
+  info,
+  options,
+  pluginOptions,
+  attributes
+};
+const revision = {
+  schema
+};
+const contentTypes = {
+  revision
+};
+const revisionController = ({ strapi }) => ({
+  /**
+   * GET /revisions
+   * Query: contentType, documentId, page?, pageSize?, includeDeleted?
+   */
+  async find(ctx) {
+    const { contentType, documentId, page, pageSize, includeDeleted } = ctx.query;
+    if (!contentType || !documentId) {
+      return ctx.badRequest("contentType and documentId are required");
+    }
+    try {
+      const result = await strapi.plugin("les-revisions").service("revision").findRevisions(contentType, documentId, {
+        page: page ? parseInt(page, 10) : 1,
+        pageSize: pageSize ? parseInt(pageSize, 10) : 25,
+        includeDeleted: includeDeleted === "true"
+      });
+      ctx.body = result;
+    } catch (error) {
+      return ctx.badRequest(error.message);
+    }
+  },
+  /**
+   * GET /revisions/:documentId
+   */
+  async findOne(ctx) {
+    const { documentId } = ctx.params;
+    try {
+      const revision2 = await strapi.plugin("les-revisions").service("revision").findOne(documentId);
+      if (!revision2) {
+        return ctx.notFound("Revision not found");
+      }
+      ctx.body = revision2;
+    } catch (error) {
+      return ctx.badRequest(error.message);
+    }
+  },
+  /**
+   * POST /revisions/:documentId/restore
+   */
+  async restore(ctx) {
+    const { documentId } = ctx.params;
+    try {
+      const restored = await strapi.plugin("les-revisions").service("revision").restore(documentId);
+      ctx.body = {
+        data: restored,
+        message: "Entry restored successfully"
+      };
+    } catch (error) {
+      return ctx.badRequest(error.message);
+    }
+  },
+  /**
+   * DELETE /revisions/:documentId
+   */
+  async delete(ctx) {
+    const { documentId } = ctx.params;
+    try {
+      await strapi.plugin("les-revisions").service("revision").deleteRevision(documentId);
+      ctx.body = { message: "Revision deleted successfully" };
+    } catch (error) {
+      return ctx.badRequest(error.message);
+    }
+  },
+  /**
+   * GET /revisions/compare
+   * Query: rev1, rev2
+   */
+  async compare(ctx) {
+    const { rev1, rev2 } = ctx.query;
+    if (!rev1 || !rev2) {
+      return ctx.badRequest("rev1 and rev2 query parameters are required");
+    }
+    try {
+      const result = await strapi.plugin("les-revisions").service("revision").compareRevisions(rev1, rev2);
+      ctx.body = result;
+    } catch (error) {
+      return ctx.badRequest(error.message);
+    }
+  },
+  /**
+   * GET /content-types
+   */
+  async getContentTypes(ctx) {
+    try {
+      const result = await strapi.plugin("les-revisions").service("revision").getContentTypesWithRevisions();
+      ctx.body = result;
+    } catch (error) {
+      return ctx.badRequest(error.message);
+    }
+  },
+  /**
+   * GET /entries
+   * Query: contentType, page?, pageSize?
+   */
+  async getEntries(ctx) {
+    const { contentType, page, pageSize } = ctx.query;
+    if (!contentType) {
+      return ctx.badRequest("contentType is required");
+    }
+    try {
+      const result = await strapi.plugin("les-revisions").service("revision").getEntriesWithRevisions(contentType, {
+        page: page ? parseInt(page, 10) : 1,
+        pageSize: pageSize ? parseInt(pageSize, 10) : 25
+      });
+      ctx.body = result;
+    } catch (error) {
+      return ctx.badRequest(error.message);
+    }
+  },
+  /**
+   * GET /config
+   */
+  async getConfig(ctx) {
+    const config2 = strapi.plugin("les-revisions").service("revision").getConfig();
+    ctx.body = config2;
+  }
+});
+const controllers = {
+  revision: revisionController
+};
+const middlewares = {};
+const policies = {};
+const contentAPIRoutes = () => ({
+  type: "content-api",
+  routes: []
+});
+const adminAPIRoutes = () => ({
+  type: "admin",
+  routes: [
+    {
+      method: "GET",
+      path: "/content-types",
+      handler: "revision.getContentTypes",
+      config: { policies: [] }
+    },
+    {
+      method: "GET",
+      path: "/entries",
+      handler: "revision.getEntries",
+      config: { policies: [] }
+    },
+    {
+      method: "GET",
+      path: "/revisions/compare",
+      handler: "revision.compare",
+      config: { policies: [] }
+    },
+    {
+      method: "GET",
+      path: "/revisions",
+      handler: "revision.find",
+      config: { policies: [] }
+    },
+    {
+      method: "GET",
+      path: "/revisions/:documentId",
+      handler: "revision.findOne",
+      config: { policies: [] }
+    },
+    {
+      method: "POST",
+      path: "/revisions/:documentId/restore",
+      handler: "revision.restore",
+      config: { policies: [] }
+    },
+    {
+      method: "DELETE",
+      path: "/revisions/:documentId",
+      handler: "revision.delete",
+      config: { policies: [] }
+    },
+    {
+      method: "GET",
+      path: "/config",
+      handler: "revision.getConfig",
+      config: { policies: [] }
+    }
+  ]
+});
+const routes = {
+  "content-api": contentAPIRoutes,
+  admin: adminAPIRoutes
+};
+const REVISION_UID = "plugin::les-revisions.revision";
+function buildDeepPopulate(uid, strapi, depth = 3, visited = /* @__PURE__ */ new Set()) {
+  if (depth <= 0 || visited.has(uid)) return true;
+  visited.add(uid);
+  const model = strapi.contentTypes[uid] || strapi.components?.[uid];
+  if (!model) return true;
+  const populate = {};
+  for (const [key, attribute] of Object.entries(model.attributes)) {
+    switch (attribute.type) {
+      case "relation": {
+        populate[key] = { populate: "*" };
+        break;
+      }
+      case "component": {
+        const sub = buildDeepPopulate(attribute.component, strapi, depth - 1, new Set(visited));
+        populate[key] = typeof sub === "object" ? { populate: sub } : { populate: "*" };
+        break;
+      }
+      case "dynamiczone": {
+        const on = {};
+        for (const componentUID of attribute.components || []) {
+          const sub = buildDeepPopulate(componentUID, strapi, depth - 1, new Set(visited));
+          on[componentUID] = typeof sub === "object" ? { populate: sub } : { populate: "*" };
+        }
+        populate[key] = { on };
+        break;
+      }
+      case "media": {
+        populate[key] = true;
+        break;
+      }
+    }
+  }
+  return Object.keys(populate).length > 0 ? populate : true;
+}
+function sanitizeSnapshot(data, excludeFields = []) {
+  if (!data || typeof data !== "object") return data;
+  const skip = /* @__PURE__ */ new Set(["createdBy", "updatedBy", ...excludeFields]);
+  const result = {};
+  for (const [key, value] of Object.entries(data)) {
+    if (skip.has(key)) continue;
+    result[key] = value;
+  }
+  return result;
+}
+function prepareRestoreData(snapshot, uid, strapi) {
+  const model = strapi.contentTypes[uid];
+  if (!model) return snapshot;
+  const internal = /* @__PURE__ */ new Set([
+    "id",
+    "documentId",
+    "createdAt",
+    "updatedAt",
+    "publishedAt",
+    "createdBy",
+    "updatedBy",
+    "locale",
+    "localizations"
+  ]);
+  const data = {};
+  for (const [key, value] of Object.entries(snapshot)) {
+    if (internal.has(key)) continue;
+    const attr = model.attributes[key];
+    if (!attr) continue;
+    switch (attr.type) {
+      case "relation":
+        data[key] = transformRelation(value);
+        break;
+      case "component":
+        data[key] = transformComponent(value, attr, strapi);
+        break;
+      case "dynamiczone":
+        data[key] = transformDynamicZone(value, strapi);
+        break;
+      case "media":
+        data[key] = transformMedia(value);
+        break;
+      default:
+        data[key] = value;
+    }
+  }
+  return data;
+}
+function transformRelation(value) {
+  if (value === null || value === void 0) return { set: [] };
+  if (Array.isArray(value)) {
+    return { set: value.filter((v) => v?.documentId).map((v) => ({ documentId: v.documentId })) };
+  }
+  if (typeof value === "object" && value.documentId) {
+    return { set: [{ documentId: value.documentId }] };
+  }
+  return { set: [] };
+}
+function transformComponent(value, attr, strapi) {
+  if (value === null || value === void 0) return null;
+  if (attr.repeatable && Array.isArray(value)) {
+    return value.map((v) => cleanComponentData(v, attr.component, strapi));
+  }
+  return cleanComponentData(value, attr.component, strapi);
+}
+function transformDynamicZone(value, strapi) {
+  if (!Array.isArray(value)) return value;
+  return value.map((v) => ({
+    __component: v.__component,
+    ...cleanComponentData(v, v.__component, strapi)
+  }));
+}
+function transformMedia(value) {
+  if (value === null || value === void 0) return null;
+  if (Array.isArray(value)) return value.map((v) => v.id).filter(Boolean);
+  if (typeof value === "object") return value.id ?? null;
+  return value;
+}
+function cleanComponentData(data, componentUID, strapi) {
+  if (!data || typeof data !== "object") return data;
+  const component = strapi.components?.[componentUID];
+  if (!component) {
+    const { id: _id, __component: _c, ...rest } = data;
+    return rest;
+  }
+  const cleaned = {};
+  for (const [key, value] of Object.entries(data)) {
+    if (key === "id" || key === "__component") continue;
+    const attr = component.attributes[key];
+    if (!attr) continue;
+    switch (attr.type) {
+      case "relation":
+        cleaned[key] = transformRelation(value);
+        break;
+      case "component":
+        cleaned[key] = transformComponent(value, attr, strapi);
+        break;
+      case "dynamiczone":
+        cleaned[key] = transformDynamicZone(value, strapi);
+        break;
+      case "media":
+        cleaned[key] = transformMedia(value);
+        break;
+      default:
+        cleaned[key] = value;
+    }
+  }
+  return cleaned;
+}
+function computeDiff(oldObj, newObj, path = "") {
+  const diffs = [];
+  const allKeys = /* @__PURE__ */ new Set([...Object.keys(oldObj ?? {}), ...Object.keys(newObj ?? {})]);
+  for (const key of allKeys) {
+    const currentPath = path ? `${path}.${key}` : key;
+    const oldVal = oldObj?.[key];
+    const newVal = newObj?.[key];
+    if (oldVal === void 0 && newVal !== void 0) {
+      diffs.push({ path: currentPath, type: "added", newValue: newVal });
+    } else if (oldVal !== void 0 && newVal === void 0) {
+      diffs.push({ path: currentPath, type: "removed", oldValue: oldVal });
+    } else if (typeof oldVal === "object" && oldVal !== null && typeof newVal === "object" && newVal !== null && !Array.isArray(oldVal) && !Array.isArray(newVal)) {
+      diffs.push(...computeDiff(oldVal, newVal, currentPath));
+    } else if (JSON.stringify(oldVal) !== JSON.stringify(newVal)) {
+      diffs.push({ path: currentPath, type: "changed", oldValue: oldVal, newValue: newVal });
+    }
+  }
+  return diffs;
+}
+function getEntryTitle(entry) {
+  if (!entry) return "Unknown";
+  return entry.title ?? entry.name ?? entry.label ?? entry.slug ?? entry.username ?? entry.email ?? entry.documentId ?? "Untitled";
+}
+const revisionService = ({ strapi }) => ({
+  /* ── Configuration ────────────────────────────────────────────────── */
+  getConfig() {
+    return strapi.config.get("plugin::les-revisions");
+  },
+  isEnabled(contentTypeUID) {
+    if (contentTypeUID === REVISION_UID) return false;
+    if (contentTypeUID.startsWith("admin::") || contentTypeUID.startsWith("plugin::") || contentTypeUID.startsWith("strapi::")) {
+      return false;
+    }
+    const config2 = this.getConfig();
+    if (config2.excludeContentTypes.includes(contentTypeUID)) return false;
+    if (config2.enabledContentTypes === "*") return true;
+    return config2.enabledContentTypes.includes(contentTypeUID);
+  },
+  getPopulate(contentTypeUID) {
+    const config2 = this.getConfig();
+    return buildDeepPopulate(contentTypeUID, strapi, config2.populateDepth);
+  },
+  /* ── CRUD ──────────────────────────────────────────────────────────── */
+  async createRevision({ contentType, documentId, snapshot, changeType, userId }) {
+    const config2 = this.getConfig();
+    const existing = await strapi.documents(REVISION_UID).findMany({
+      filters: {
+        contentType: { $eq: contentType },
+        entryDocumentId: { $eq: documentId },
+        isDeleted: { $eq: false }
+      },
+      sort: { version: "desc" },
+      limit: 1
+    });
+    const nextVersion = existing.length > 0 ? (existing[0].version ?? 0) + 1 : 1;
+    let changedByName = null;
+    let changedByEmail = null;
+    let changedById = null;
+    if (userId) {
+      try {
+        const user = await strapi.query("admin::user").findOne({ where: { id: userId } });
+        if (user) {
+          changedByName = `${user.firstname ?? ""} ${user.lastname ?? ""}`.trim() || null;
+          changedByEmail = user.email ?? null;
+          changedById = user.id;
+        }
+      } catch {
+      }
+    }
+    const sanitized = sanitizeSnapshot(snapshot, config2.excludeFields);
+    const revision2 = await strapi.documents(REVISION_UID).create({
+      data: {
+        contentType,
+        entryDocumentId: documentId,
+        version: nextVersion,
+        snapshot: sanitized,
+        changeType,
+        changedByName,
+        changedByEmail,
+        changedById,
+        isDeleted: false,
+        metadata: {
+          locale: snapshot?.locale ?? null,
+          publishedAt: snapshot?.publishedAt ?? null
+        }
+      }
+    });
+    await this.pruneRevisions(contentType, documentId);
+    return revision2;
+  },
+  async findRevisions(contentType, documentId, params = {}) {
+    const { page = 1, pageSize = 25, includeDeleted = false } = params;
+    const filters = {
+      contentType: { $eq: contentType },
+      entryDocumentId: { $eq: documentId }
+    };
+    if (!includeDeleted) {
+      filters.isDeleted = { $eq: false };
+    }
+    const start = (page - 1) * pageSize;
+    const [revisions, total] = await Promise.all([
+      strapi.documents(REVISION_UID).findMany({
+        filters,
+        sort: { version: "desc" },
+        start,
+        limit: pageSize
+      }),
+      strapi.db.query(REVISION_UID).count({ where: this._filtersToWhere(filters) })
+    ]);
+    return {
+      results: revisions,
+      pagination: {
+        page,
+        pageSize,
+        pageCount: Math.ceil(total / pageSize),
+        total
+      }
+    };
+  },
+  async findOne(revisionDocumentId) {
+    return strapi.documents(REVISION_UID).findOne({
+      documentId: revisionDocumentId
+    });
+  },
+  /* ── Restore ───────────────────────────────────────────────────────── */
+  async restore(revisionDocumentId) {
+    const revision2 = await strapi.documents(REVISION_UID).findOne({
+      documentId: revisionDocumentId
+    });
+    if (!revision2) throw new Error("Revision not found");
+    const { contentType, entryDocumentId, snapshot } = revision2;
+    if (!strapi.contentTypes[contentType]) {
+      throw new Error(`Content-type ${contentType} no longer exists`);
+    }
+    const currentEntry = await strapi.documents(contentType).findOne({
+      documentId: entryDocumentId,
+      populate: this.getPopulate(contentType)
+    });
+    if (!currentEntry) {
+      throw new Error(`Entry ${entryDocumentId} no longer exists in ${contentType}`);
+    }
+    const ctx = strapi.requestContext?.get?.();
+    const userId = ctx?.state?.user?.id ?? null;
+    await this.createRevision({
+      contentType,
+      documentId: entryDocumentId,
+      snapshot: currentEntry,
+      changeType: "update",
+      userId
+    });
+    const restoreData = prepareRestoreData(snapshot, contentType, strapi);
+    if (ctx) {
+      ctx.state = ctx.state || {};
+      ctx.state._lesRevisionsSkip = true;
+    }
+    try {
+      const restored = await strapi.documents(contentType).update({
+        documentId: entryDocumentId,
+        data: restoreData,
+        populate: this.getPopulate(contentType)
+      });
+      return restored;
+    } finally {
+      if (ctx?.state) {
+        ctx.state._lesRevisionsSkip = false;
+      }
+    }
+  },
+  /* ── Delete ────────────────────────────────────────────────────────── */
+  async deleteRevision(revisionDocumentId) {
+    const config2 = this.getConfig();
+    if (config2.softDelete) {
+      return strapi.documents(REVISION_UID).update({
+        documentId: revisionDocumentId,
+        data: { isDeleted: true }
+      });
+    }
+    return strapi.documents(REVISION_UID).delete({
+      documentId: revisionDocumentId
+    });
+  },
+  /* ── Compare ───────────────────────────────────────────────────────── */
+  async compareRevisions(docId1, docId2) {
+    const [rev1, rev2] = await Promise.all([
+      strapi.documents(REVISION_UID).findOne({ documentId: docId1 }),
+      strapi.documents(REVISION_UID).findOne({ documentId: docId2 })
+    ]);
+    if (!rev1 || !rev2) throw new Error("One or both revisions not found");
+    const r1 = rev1;
+    const r2 = rev2;
+    if (r1.contentType !== r2.contentType || r1.entryDocumentId !== r2.entryDocumentId) {
+      throw new Error("Cannot compare revisions from different entries");
+    }
+    return {
+      revision1: rev1,
+      revision2: rev2,
+      diff: computeDiff(r1.snapshot ?? {}, r2.snapshot ?? {})
+    };
+  },
+  /* ── Pruning ───────────────────────────────────────────────────────── */
+  async pruneRevisions(contentType, documentId) {
+    const config2 = this.getConfig();
+    const { maxVersions, softDelete } = config2;
+    const all = await strapi.documents(REVISION_UID).findMany({
+      filters: {
+        contentType: { $eq: contentType },
+        entryDocumentId: { $eq: documentId },
+        isDeleted: { $eq: false }
+      },
+      sort: { version: "desc" }
+    });
+    if (all.length <= maxVersions) return;
+    const toRemove = all.slice(maxVersions);
+    for (const rev of toRemove) {
+      const docId = rev.documentId;
+      if (softDelete) {
+        await strapi.documents(REVISION_UID).update({
+          documentId: docId,
+          data: { isDeleted: true }
+        });
+      } else {
+        await strapi.documents(REVISION_UID).delete({ documentId: docId });
+      }
+    }
+  },
+  /* ── Listing helpers (admin UI) ────────────────────────────────────── */
+  async getContentTypesWithRevisions() {
+    const contentTypes2 = Object.entries(strapi.contentTypes).filter(([uid]) => this.isEnabled(uid)).map(([uid, ct]) => ({ uid, info: ct.info }));
+    const result = [];
+    for (const ct of contentTypes2) {
+      const count = await strapi.db.query(REVISION_UID).count({
+        where: { contentType: ct.uid, isDeleted: false }
+      });
+      result.push({ ...ct, revisionCount: count });
+    }
+    return result;
+  },
+  async getEntriesWithRevisions(contentType, params = {}) {
+    const { page = 1, pageSize = 25 } = params;
+    const revisions = await strapi.documents(REVISION_UID).findMany({
+      filters: {
+        contentType: { $eq: contentType },
+        isDeleted: { $eq: false }
+      },
+      sort: { createdAt: "desc" }
+    });
+    const entryMap = /* @__PURE__ */ new Map();
+    for (const rev of revisions) {
+      const r = rev;
+      const entry = entryMap.get(r.entryDocumentId);
+      if (!entry) {
+        entryMap.set(r.entryDocumentId, {
+          documentId: r.entryDocumentId,
+          count: 1,
+          lastModified: r.createdAt,
+          lastVersion: r.version
+        });
+      } else {
+        entry.count++;
+        if (r.version > entry.lastVersion) {
+          entry.lastModified = r.createdAt;
+          entry.lastVersion = r.version;
+        }
+      }
+    }
+    const entries = Array.from(entryMap.values()).sort((a, b) => new Date(b.lastModified).getTime() - new Date(a.lastModified).getTime());
+    const total = entries.length;
+    const start = (page - 1) * pageSize;
+    const paged = entries.slice(start, start + pageSize);
+    const enriched = [];
+    for (const entry of paged) {
+      try {
+        const doc = await strapi.documents(contentType).findOne({
+          documentId: entry.documentId
+        });
+        enriched.push({
+          ...entry,
+          entryTitle: getEntryTitle(doc),
+          exists: !!doc
+        });
+      } catch {
+        enriched.push({
+          ...entry,
+          entryTitle: `[Supprimé] ${entry.documentId}`,
+          exists: false
+        });
+      }
+    }
+    return {
+      results: enriched,
+      pagination: {
+        page,
+        pageSize,
+        pageCount: Math.ceil(total / pageSize),
+        total
+      }
+    };
+  },
+  /**
+   * Soft-delete all revisions for an entry (called on entry hard-delete).
+   */
+  async deleteAllRevisionsForEntry(contentType, documentId) {
+    const config2 = this.getConfig();
+    const revisions = await strapi.documents(REVISION_UID).findMany({
+      filters: {
+        contentType: { $eq: contentType },
+        entryDocumentId: { $eq: documentId }
+      }
+    });
+    for (const rev of revisions) {
+      const docId = rev.documentId;
+      if (config2.softDelete) {
+        await strapi.documents(REVISION_UID).update({
+          documentId: docId,
+          data: { isDeleted: true }
+        });
+      } else {
+        await strapi.documents(REVISION_UID).delete({ documentId: docId });
+      }
+    }
+  },
+  /* ── Internal utilities ────────────────────────────────────────────── */
+  /** Convert Document Service filters to query-engine where clause */
+  _filtersToWhere(filters) {
+    const where = {};
+    for (const [key, condition] of Object.entries(filters)) {
+      if (typeof condition === "object" && condition !== null) {
+        if ("$eq" in condition) where[key] = condition.$eq;
+        else where[key] = condition;
+      } else {
+        where[key] = condition;
+      }
+    }
+    return where;
+  }
+});
+const services = {
+  revision: revisionService
+};
+const index = {
+  register,
+  bootstrap,
+  destroy,
+  config,
+  controllers,
+  routes,
+  services,
+  contentTypes,
+  policies,
+  middlewares
+};
+module.exports = index;