strapi-plugin-timeline 0.0.0

package/dist/server/index.mjs

@@ -0,0 +1,1037 @@
+const IGNORED_UIDS = /* @__PURE__ */ new Set([
+  "plugin::timeline.timeline-entry",
+  "plugin::timeline.timeline-setting"
+]);
+const restoreInProgress = /* @__PURE__ */ new Set();
+function markRestoreInProgress(key) {
+  restoreInProgress.add(key);
+}
+function clearRestoreInProgress(key) {
+  restoreInProgress.delete(key);
+}
+function isRestoreInProgress(key) {
+  return restoreInProgress.has(key);
+}
+function getRequestUser(strapi) {
+  try {
+    const ctx = strapi.requestContext?.get?.();
+    const user = ctx?.state?.user;
+    if (!user?.id) return null;
+    const name = [user.firstname, user.lastname].filter(Boolean).join(" ") || user.email || null;
+    return { id: user.id, name: name || `User #${user.id}` };
+  } catch {
+    return null;
+  }
+}
+async function isTracked(strapi, uid, action) {
+  if (!uid.startsWith("api::")) return false;
+  if (IGNORED_UIDS.has(uid)) return false;
+  try {
+    const settings = await strapi.plugin("timeline").service("settings").getSettings();
+    const config2 = settings.contentTypeConfigs?.[uid];
+    if (!config2 || !config2.enabled) return false;
+    if (action && Array.isArray(config2.actions) && config2.actions.length > 0) {
+      return config2.actions.includes(action);
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getRelationAttributeDetails(strapi, uid) {
+  const ct = strapi.contentTypes[uid];
+  if (!ct?.attributes) return {};
+  const result = {};
+  for (const [name, attr] of Object.entries(ct.attributes)) {
+    const a = attr;
+    if (a.type === "relation" && a.target) {
+      result[name] = { target: a.target, relation: a.relation || "" };
+    }
+  }
+  return result;
+}
+function extractAttributesSchema(strapi, attributes2, visited = /* @__PURE__ */ new Set()) {
+  const schema2 = {};
+  for (const [name, attr] of Object.entries(attributes2)) {
+    const a = attr;
+    const entry = { type: a.type };
+    if (a.type === "relation") {
+      entry.target = a.target || null;
+      entry.relation = a.relation || null;
+    }
+    if (a.type === "component") {
+      entry.component = a.component || null;
+      entry.repeatable = a.repeatable || false;
+      if (a.component && !visited.has(a.component)) {
+        const comp = strapi.components?.[a.component];
+        if (comp?.attributes) {
+          visited.add(a.component);
+          entry.reference = extractAttributesSchema(strapi, comp.attributes, visited);
+        }
+      }
+    }
+    if (a.type === "dynamiczone") {
+      entry.components = a.components || [];
+      const references = {};
+      for (const compUid of a.components || []) {
+        if (visited.has(compUid)) continue;
+        const comp = strapi.components?.[compUid];
+        if (comp?.attributes) {
+          visited.add(compUid);
+          references[compUid] = extractAttributesSchema(strapi, comp.attributes, visited);
+        }
+      }
+      if (Object.keys(references).length > 0) {
+        entry.references = references;
+      }
+    }
+    if (a.type === "customField" && a.customField) {
+      entry.customField = a.customField;
+      try {
+        const cfReg = strapi.customFields?.get?.(a.customField);
+        if (cfReg?.type) {
+          entry.customFieldType = cfReg.type;
+        }
+      } catch {
+      }
+    }
+    schema2[name] = entry;
+  }
+  return schema2;
+}
+function extractSchema(strapi, uid) {
+  const ct = strapi.contentTypes[uid];
+  if (!ct?.attributes) return {};
+  return extractAttributesSchema(strapi, ct.attributes, /* @__PURE__ */ new Set([uid]));
+}
+async function resolveRelations(strapi, uid, entryId, rawContent) {
+  const relationDetails = getRelationAttributeDetails(strapi, uid);
+  const relationNames = Object.keys(relationDetails);
+  if (relationNames.length === 0) return rawContent;
+  try {
+    const populate = {};
+    for (const attr of relationNames) {
+      const { target } = relationDetails[attr];
+      const isUsersPermissions = target.startsWith("plugin::users-permissions.");
+      const isAdminUser = target === "admin::user";
+      if (isUsersPermissions) {
+        populate[attr] = { fields: ["id"] };
+      } else if (isAdminUser) {
+        populate[attr] = { fields: ["id", "firstname", "lastname", "email"] };
+      } else if (attr === "localizations") {
+        populate[attr] = { fields: ["documentId", "locale"] };
+      } else {
+        populate[attr] = { fields: ["documentId"] };
+      }
+    }
+    const populated = await strapi.db.query(uid).findOne({
+      where: { id: entryId },
+      populate
+    });
+    if (!populated) return rawContent;
+    const content = { ...rawContent };
+    for (const attr of relationNames) {
+      const val = populated[attr];
+      const { target } = relationDetails[attr];
+      const isUsersPermissions = target.startsWith("plugin::users-permissions.");
+      const isAdminUser = target === "admin::user";
+      if (val == null) {
+        content[attr] = null;
+      } else if (isAdminUser) {
+        if (Array.isArray(val)) {
+          content[attr] = val.map((r) => ({
+            id: r.id,
+            firstname: r.firstname,
+            lastname: r.lastname,
+            email: r.email
+          }));
+        } else {
+          content[attr] = {
+            id: val.id,
+            firstname: val.firstname,
+            lastname: val.lastname,
+            email: val.email
+          };
+        }
+      } else if (attr === "localizations") {
+        if (Array.isArray(val)) {
+          content[attr] = val.map((r) => ({
+            documentId: r.documentId,
+            locale: r.locale
+          })).filter((r) => r.documentId);
+        } else if (val.documentId) {
+          content[attr] = [{ documentId: val.documentId, locale: val.locale }];
+        }
+      } else {
+        const idField = isUsersPermissions ? "id" : "documentId";
+        if (Array.isArray(val)) {
+          content[attr] = val.map((r) => r[idField]).filter(Boolean);
+        } else if (val[idField]) {
+          content[attr] = val[idField];
+        }
+      }
+    }
+    return content;
+  } catch {
+    return rawContent;
+  }
+}
+const bootstrap = async ({ strapi }) => {
+  strapi.log.info("[Timeline] Registering global lifecycle hooks (collections checked dynamically).");
+  strapi.db.lifecycles.subscribe({
+    async afterCreate(event) {
+      try {
+        const { result, model } = event;
+        if (!result) return;
+        const ct = strapi.contentTypes[model.uid];
+        const hasDraftAndPublish = ct?.options?.draftAndPublish !== false;
+        const isPublish = hasDraftAndPublish && result.publishedAt != null;
+        const action = isPublish ? "publish" : "create";
+        if (!await isTracked(strapi, model.uid, action)) return;
+        const reqUser = getRequestUser(strapi);
+        const content = await resolveRelations(strapi, model.uid, result.id, { ...result });
+        const contentTypeSchema = extractSchema(strapi, model.uid);
+        await strapi.plugin("timeline").service("timeline").createSnapshot({
+          action,
+          contentType: model.uid,
+          entryDocumentId: result.documentId || String(result.id),
+          content,
+          contentTypeSchema,
+          userId: reqUser?.id || null,
+          userName: reqUser?.name || null,
+          locale: result.locale || null
+        });
+        await strapi.plugin("timeline").service("timeline").enforceEntriesLimit(model.uid);
+      } catch (error) {
+        strapi.log.error(`[Timeline] afterCreate error: ${error}`);
+      }
+    },
+    async afterUpdate(event) {
+      try {
+        const { result, model } = event;
+        if (!result) return;
+        const docId = result.documentId || String(result.id);
+        const restoreKey = `${model.uid}:${docId}`;
+        if (isRestoreInProgress(restoreKey)) return;
+        const ct = strapi.contentTypes[model.uid];
+        const hasDraftAndPublish = ct?.options?.draftAndPublish !== false;
+        if (hasDraftAndPublish && result.publishedAt != null) return;
+        if (!await isTracked(strapi, model.uid, "update")) return;
+        const reqUser = getRequestUser(strapi);
+        const content = await resolveRelations(strapi, model.uid, result.id, { ...result });
+        const contentTypeSchema = extractSchema(strapi, model.uid);
+        await strapi.plugin("timeline").service("timeline").createSnapshot({
+          action: "update",
+          contentType: model.uid,
+          entryDocumentId: result.documentId || String(result.id),
+          content,
+          contentTypeSchema,
+          userId: reqUser?.id || null,
+          userName: reqUser?.name || null,
+          locale: result.locale || null
+        });
+        await strapi.plugin("timeline").service("timeline").enforceEntriesLimit(model.uid);
+      } catch (error) {
+        strapi.log.error(`[Timeline] afterUpdate error: ${error}`);
+      }
+    },
+    async beforeDelete(event) {
+      try {
+        const { params, model } = event;
+        if (!await isTracked(strapi, model.uid, "delete")) return;
+        const where = params.where || {};
+        const entries = await strapi.db.query(model.uid).findMany({ where });
+        for (const entry of entries) {
+          const ct = strapi.contentTypes[model.uid];
+          const hasDraftAndPublish = ct?.options?.draftAndPublish !== false;
+          if (hasDraftAndPublish && entry.publishedAt != null) continue;
+          const reqUser = getRequestUser(strapi);
+          const content = await resolveRelations(strapi, model.uid, entry.id, { ...entry });
+          const contentTypeSchema = extractSchema(strapi, model.uid);
+          await strapi.plugin("timeline").service("timeline").createSnapshot({
+            action: "delete",
+            contentType: model.uid,
+            entryDocumentId: entry.documentId || String(entry.id),
+            content,
+            contentTypeSchema,
+            userId: reqUser?.id || null,
+            userName: reqUser?.name || null,
+            locale: entry.locale || null
+          });
+        }
+      } catch (error) {
+        strapi.log.error(`[Timeline] beforeDelete error: ${error}`);
+      }
+    }
+  });
+  try {
+    const settings = await strapi.plugin("timeline").service("settings").getSettings();
+    if (settings.cleanupEnabled && settings.cleanupCron) {
+      strapi.cron.add({
+        "timeline-cleanup": {
+          task: async ({ strapi: s }) => {
+            s.log.info("[Timeline] Running scheduled cleanup...");
+            try {
+              const results = await s.plugin("timeline").service("schedule").runCleanup();
+              s.log.info(`[Timeline] Cleanup complete: ${JSON.stringify(results)}`);
+            } catch (err) {
+              s.log.error(`[Timeline] Cleanup failed: ${err}`);
+            }
+          },
+          options: settings.cleanupCron
+        }
+      });
+      strapi.log.info(`[Timeline] Registered cleanup cron: ${settings.cleanupCron}`);
+    }
+  } catch (error) {
+    strapi.log.error(`[Timeline] Failed to register cleanup cron: ${error}`);
+  }
+};
+const destroy = ({ strapi }) => {
+};
+const register = ({ strapi }) => {
+  const actions = [
+    {
+      uid: "entries.read",
+      displayName: "Read timeline entries",
+      pluginName: "timeline",
+      section: "plugins"
+    },
+    {
+      uid: "entries.delete",
+      displayName: "Delete all timeline entries",
+      pluginName: "timeline",
+      section: "plugins"
+    },
+    {
+      uid: "settings.read",
+      displayName: "Read timeline settings",
+      pluginName: "timeline",
+      section: "plugins"
+    },
+    {
+      uid: "settings.edit",
+      displayName: "Edit timeline settings",
+      pluginName: "timeline",
+      section: "plugins"
+    },
+    {
+      uid: "schedule.read",
+      displayName: "Read timeline schedule",
+      pluginName: "timeline",
+      section: "plugins"
+    },
+    {
+      uid: "schedule.run",
+      displayName: "Run timeline cleanup",
+      pluginName: "timeline",
+      section: "plugins"
+    }
+  ];
+  strapi.admin?.services.permission.actionProvider.registerMany(actions);
+};
+const config = {
+  default: {},
+  validator() {
+  }
+};
+const kind$1 = "singleType";
+const collectionName$1 = "timeline_settings";
+const info$1 = { "singularName": "timeline-setting", "pluralName": "timeline-settings", "displayName": "Timeline Settings" };
+const pluginOptions$1 = { "content-manager": { "visible": false }, "content-type-builder": { "visible": false } };
+const options$1 = { "draftAndPublish": false };
+const attributes$1 = { "trackedContentTypes": { "type": "json", "default": [] }, "contentTypeConfigs": { "type": "json", "default": {} }, "cleanupEnabled": { "type": "boolean", "default": false }, "cleanupCron": { "type": "string", "default": "0 * * * *" }, "lastCleanupAt": { "type": "datetime" }, "lastCleanupResults": { "type": "json" } };
+const schema$1 = {
+  kind: kind$1,
+  collectionName: collectionName$1,
+  info: info$1,
+  pluginOptions: pluginOptions$1,
+  options: options$1,
+  attributes: attributes$1
+};
+const timelineSetting = {
+  schema: schema$1
+};
+const kind = "collectionType";
+const collectionName = "timeline_entries";
+const info = { "singularName": "timeline-entry", "pluralName": "timeline-entries", "displayName": "Timeline Entry" };
+const pluginOptions = { "content-manager": { "visible": false }, "content-type-builder": { "visible": false } };
+const options = { "draftAndPublish": false };
+const attributes = { "action": { "type": "string", "required": true }, "contentType": { "type": "string", "required": true }, "entryDocumentId": { "type": "string", "required": true }, "content": { "type": "json" }, "userId": { "type": "integer" }, "userName": { "type": "string" }, "locale": { "type": "string" }, "contentTypeSchema": { "type": "json" } };
+const schema = {
+  kind,
+  collectionName,
+  info,
+  pluginOptions,
+  options,
+  attributes
+};
+const timelineEntry = {
+  schema
+};
+const contentTypes = {
+  "timeline-setting": timelineSetting,
+  "timeline-entry": timelineEntry
+};
+const controller = ({ strapi }) => ({
+  index(ctx) {
+    ctx.body = strapi.plugin("timeline").service("service").getWelcomeMessage();
+  }
+});
+const settingsController = ({ strapi }) => ({
+  async getSettings(ctx) {
+    const settings = await strapi.plugin("timeline").service("settings").getSettings();
+    ctx.body = { data: settings };
+  },
+  async setSettings(ctx) {
+    const { contentTypeConfigs } = ctx.request.body;
+    const settings = await strapi.plugin("timeline").service("settings").setSettings({
+      contentTypeConfigs: contentTypeConfigs || {}
+    });
+    ctx.body = { data: settings };
+  },
+  async getContentTypes(ctx) {
+    const contentTypes2 = await strapi.plugin("timeline").service("settings").getContentTypes();
+    ctx.body = { data: contentTypes2 };
+  }
+});
+const timelineController = ({ strapi }) => ({
+  async find(ctx) {
+    const {
+      contentType,
+      entryDocumentId,
+      userId,
+      action,
+      locale,
+      dateFrom,
+      dateTo,
+      sort,
+      sortOrder,
+      page = "1",
+      pageSize = "20"
+    } = ctx.query;
+    const result = await strapi.plugin("timeline").service("timeline").findEntries({
+      contentType: contentType || void 0,
+      entryDocumentId: entryDocumentId || void 0,
+      userId: userId || void 0,
+      action: action || void 0,
+      locale: locale || void 0,
+      dateFrom: dateFrom || void 0,
+      dateTo: dateTo || void 0,
+      sort: sort || void 0,
+      sortOrder: sortOrder || void 0,
+      page: parseInt(page, 10),
+      pageSize: parseInt(pageSize, 10)
+    });
+    ctx.body = { data: result.results, meta: { pagination: result.pagination } };
+  },
+  async findByDocument(ctx) {
+    const contentType = decodeURIComponent(ctx.params.contentType || "");
+    const entryDocumentId = decodeURIComponent(ctx.params.entryDocumentId || "");
+    if (!contentType || !entryDocumentId) {
+      return ctx.badRequest("contentType and entryDocumentId are required");
+    }
+    const entries = await strapi.plugin("timeline").service("timeline").findByDocumentId(contentType, entryDocumentId);
+    ctx.body = { data: entries };
+  },
+  async getUsers(ctx) {
+    const users = await strapi.plugin("timeline").service("timeline").getDistinctUsers();
+    ctx.body = { data: users };
+  },
+  async getLocales(ctx) {
+    const locales = await strapi.plugin("timeline").service("timeline").getDistinctLocales();
+    ctx.body = { data: locales };
+  },
+  async deleteAll(ctx) {
+    await strapi.plugin("timeline").service("timeline").deleteAll();
+    ctx.body = { data: { success: true } };
+  },
+  async clean(ctx) {
+    const { contentTypes: contentTypesToClean } = ctx.request.body || {};
+    if (!Array.isArray(contentTypesToClean) || contentTypesToClean.length === 0) {
+      return ctx.badRequest("contentTypes array is required");
+    }
+    const validUids = contentTypesToClean.filter(
+      (uid) => typeof uid === "string" && uid.startsWith("api::")
+    );
+    if (validUids.length === 0) {
+      return ctx.badRequest("No valid content type UIDs provided");
+    }
+    const user = ctx.state?.user;
+    const userId = user?.id || null;
+    const userName = user ? [user.firstname, user.lastname].filter(Boolean).join(" ") || user.email || `User #${user.id}` : null;
+    const deleted = await strapi.plugin("timeline").service("timeline").deleteByContentTypes(validUids);
+    for (const uid of validUids) {
+      await strapi.plugin("timeline").service("timeline").createSnapshot({
+        action: "clean",
+        contentType: uid,
+        entryDocumentId: "CLEAN",
+        content: { cleanedAt: (/* @__PURE__ */ new Date()).toISOString(), deletedCount: deleted },
+        userId,
+        userName
+      });
+    }
+    ctx.body = { data: { success: true, deleted } };
+  },
+  async snapshotBeforeRestore(ctx) {
+    const { contentType, entryDocumentId, locale, restoreData } = ctx.request.body || {};
+    if (!contentType || !entryDocumentId) {
+      return ctx.badRequest("contentType and entryDocumentId are required");
+    }
+    const user = ctx.state?.user;
+    const userId = user?.id || null;
+    const userName = user ? [user.firstname, user.lastname].filter(Boolean).join(" ") || user.email || `User #${user.id}` : null;
+    const restoreKey = `${contentType}:${entryDocumentId}`;
+    try {
+      const docService = strapi.documents(contentType);
+      const findParams = { documentId: entryDocumentId };
+      if (locale) findParams.locale = locale;
+      const currentDoc = await docService.findOne(findParams);
+      if (!currentDoc) {
+        ctx.body = { data: { success: false, reason: "Entry not found" } };
+        return;
+      }
+      if (restoreData && typeof restoreData === "object") {
+        markRestoreInProgress(restoreKey);
+        try {
+          const updateParams = {
+            documentId: entryDocumentId,
+            data: restoreData
+          };
+          if (locale) updateParams.locale = locale;
+          await docService.update(updateParams);
+        } finally {
+          clearRestoreInProgress(restoreKey);
+        }
+      }
+      const updatedDoc = restoreData ? await docService.findOne(findParams) : null;
+      await strapi.plugin("timeline").service("timeline").createSnapshot({
+        action: "restore",
+        contentType,
+        entryDocumentId,
+        content: updatedDoc || currentDoc,
+        userId,
+        userName,
+        locale: locale || currentDoc.locale || null
+      });
+      await strapi.plugin("timeline").service("timeline").enforceEntriesLimit(contentType);
+      ctx.body = { data: { success: true } };
+    } catch (error) {
+      clearRestoreInProgress(restoreKey);
+      strapi.log.error(`[Timeline] Failed to restore: ${error}`);
+      ctx.internalServerError("Restore failed");
+    }
+  }
+});
+const scheduleController = ({ strapi }) => ({
+  async getStatus(ctx) {
+    const status = await strapi.plugin("timeline").service("schedule").getStatus();
+    ctx.body = { data: status };
+  },
+  async runCleanup(ctx) {
+    const results = await strapi.plugin("timeline").service("schedule").runCleanup();
+    ctx.body = { data: { results, ranAt: (/* @__PURE__ */ new Date()).toISOString() } };
+  },
+  async updateSchedule(ctx) {
+    const { cleanupEnabled, cleanupCron } = ctx.request.body;
+    await strapi.plugin("timeline").service("settings").updateScheduleConfig({
+      cleanupEnabled,
+      cleanupCron
+    });
+    ctx.body = {
+      data: {
+        success: true,
+        note: "Cron schedule changes take effect after server restart."
+      }
+    };
+  }
+});
+const controllers = {
+  controller,
+  settings: settingsController,
+  timeline: timelineController,
+  schedule: scheduleController
+};
+const middlewares = {};
+const policies = {};
+const contentAPIRoutes = () => ({
+  type: "content-api",
+  routes: [
+    {
+      method: "GET",
+      path: "/",
+      // name of the controller file & the method.
+      handler: "controller.index",
+      config: {
+        policies: []
+      }
+    }
+  ]
+});
+const adminAPIRoutes = () => ({
+  type: "admin",
+  routes: [
+    {
+      method: "GET",
+      path: "/settings",
+      handler: "settings.getSettings",
+      config: {
+        policies: [
+          "admin::isAuthenticatedAdmin",
+          { name: "admin::hasPermissions", config: { actions: ["plugin::timeline.settings.read"] } }
+        ]
+      }
+    },
+    {
+      method: "PUT",
+      path: "/settings",
+      handler: "settings.setSettings",
+      config: {
+        policies: [
+          "admin::isAuthenticatedAdmin",
+          { name: "admin::hasPermissions", config: { actions: ["plugin::timeline.settings.edit"] } }
+        ]
+      }
+    },
+    {
+      method: "GET",
+      path: "/content-types",
+      handler: "settings.getContentTypes",
+      config: {
+        policies: ["admin::isAuthenticatedAdmin"]
+      }
+    },
+    {
+      method: "GET",
+      path: "/entries",
+      handler: "timeline.find",
+      config: {
+        policies: [
+          "admin::isAuthenticatedAdmin",
+          { name: "admin::hasPermissions", config: { actions: ["plugin::timeline.entries.read"] } }
+        ]
+      }
+    },
+    {
+      method: "GET",
+      path: "/entries/users",
+      handler: "timeline.getUsers",
+      config: {
+        policies: [
+          "admin::isAuthenticatedAdmin",
+          { name: "admin::hasPermissions", config: { actions: ["plugin::timeline.entries.read"] } }
+        ]
+      }
+    },
+    {
+      method: "GET",
+      path: "/entries/locales",
+      handler: "timeline.getLocales",
+      config: {
+        policies: [
+          "admin::isAuthenticatedAdmin",
+          { name: "admin::hasPermissions", config: { actions: ["plugin::timeline.entries.read"] } }
+        ]
+      }
+    },
+    {
+      method: "DELETE",
+      path: "/entries",
+      handler: "timeline.deleteAll",
+      config: {
+        policies: [
+          "admin::isAuthenticatedAdmin",
+          { name: "admin::hasPermissions", config: { actions: ["plugin::timeline.entries.delete"] } }
+        ]
+      }
+    },
+    {
+      method: "POST",
+      path: "/entries/clean",
+      handler: "timeline.clean",
+      config: {
+        policies: [
+          "admin::isAuthenticatedAdmin",
+          { name: "admin::hasPermissions", config: { actions: ["plugin::timeline.entries.delete"] } }
+        ]
+      }
+    },
+    {
+      method: "POST",
+      path: "/entries/snapshot-before-restore",
+      handler: "timeline.snapshotBeforeRestore",
+      config: {
+        policies: [
+          "admin::isAuthenticatedAdmin",
+          { name: "admin::hasPermissions", config: { actions: ["plugin::timeline.entries.read"] } }
+        ]
+      }
+    },
+    {
+      method: "GET",
+      path: "/entries/:contentType/:entryDocumentId",
+      handler: "timeline.findByDocument",
+      config: {
+        policies: [
+          "admin::isAuthenticatedAdmin",
+          { name: "admin::hasPermissions", config: { actions: ["plugin::timeline.entries.read"] } }
+        ]
+      }
+    },
+    {
+      method: "GET",
+      path: "/schedule",
+      handler: "schedule.getStatus",
+      config: {
+        policies: [
+          "admin::isAuthenticatedAdmin",
+          { name: "admin::hasPermissions", config: { actions: ["plugin::timeline.schedule.read"] } }
+        ]
+      }
+    },
+    {
+      method: "POST",
+      path: "/schedule/run",
+      handler: "schedule.runCleanup",
+      config: {
+        policies: [
+          "admin::isAuthenticatedAdmin",
+          { name: "admin::hasPermissions", config: { actions: ["plugin::timeline.schedule.run"] } }
+        ]
+      }
+    },
+    {
+      method: "PUT",
+      path: "/schedule",
+      handler: "schedule.updateSchedule",
+      config: {
+        policies: [
+          "admin::isAuthenticatedAdmin",
+          { name: "admin::hasPermissions", config: { actions: ["plugin::timeline.settings.edit"] } }
+        ]
+      }
+    }
+  ]
+});
+const routes = {
+  "content-api": contentAPIRoutes,
+  admin: adminAPIRoutes
+};
+const service = ({ strapi }) => ({
+  getWelcomeMessage() {
+    return "Welcome to Strapi 🚀";
+  }
+});
+const SETTINGS_UID = "plugin::timeline.timeline-setting";
+const DEFAULT_ACTIONS = ["create", "update", "delete", "publish"];
+const settingsService = ({ strapi }) => ({
+  async getSettings() {
+    const raw = await strapi.db.query(SETTINGS_UID).findOne({ where: {} });
+    if (!raw) {
+      return {
+        contentTypeConfigs: {},
+        cleanupEnabled: false,
+        cleanupCron: "0 * * * *",
+        lastCleanupAt: null,
+        lastCleanupResults: null
+      };
+    }
+    let contentTypeConfigs = raw.contentTypeConfigs || {};
+    const oldList = raw.trackedContentTypes || [];
+    if (Object.keys(contentTypeConfigs).length === 0 && Array.isArray(oldList) && oldList.length > 0) {
+      for (const uid of oldList) {
+        if (typeof uid === "string" && uid) {
+          contentTypeConfigs[uid] = {
+            enabled: true,
+            actions: [...DEFAULT_ACTIONS],
+            entriesLimit: 0,
+            durationLimit: 0,
+            durationUnit: "days"
+          };
+        }
+      }
+      await strapi.db.query(SETTINGS_UID).update({
+        where: { id: raw.id },
+        data: { contentTypeConfigs, trackedContentTypes: [] }
+      });
+    }
+    return {
+      contentTypeConfigs,
+      cleanupEnabled: raw.cleanupEnabled ?? false,
+      cleanupCron: raw.cleanupCron || "0 * * * *",
+      lastCleanupAt: raw.lastCleanupAt || null,
+      lastCleanupResults: raw.lastCleanupResults || null
+    };
+  },
+  async setSettings(data) {
+    const existing = await strapi.db.query(SETTINGS_UID).findOne({ where: {} });
+    const payload = {
+      contentTypeConfigs: data.contentTypeConfigs,
+      trackedContentTypes: []
+      // clear old format
+    };
+    if (existing) {
+      return strapi.db.query(SETTINGS_UID).update({
+        where: { id: existing.id },
+        data: payload
+      });
+    }
+    return strapi.db.query(SETTINGS_UID).create({ data: payload });
+  },
+  async updateScheduleConfig(data) {
+    const existing = await strapi.db.query(SETTINGS_UID).findOne({ where: {} });
+    const payload = {};
+    if (data.cleanupEnabled !== void 0) payload.cleanupEnabled = data.cleanupEnabled;
+    if (data.cleanupCron !== void 0) payload.cleanupCron = data.cleanupCron;
+    if (existing) {
+      return strapi.db.query(SETTINGS_UID).update({
+        where: { id: existing.id },
+        data: payload
+      });
+    }
+    return strapi.db.query(SETTINGS_UID).create({ data: payload });
+  },
+  async updateCleanupResults(data) {
+    const existing = await strapi.db.query(SETTINGS_UID).findOne({ where: {} });
+    if (existing) {
+      return strapi.db.query(SETTINGS_UID).update({
+        where: { id: existing.id },
+        data
+      });
+    }
+  },
+  async getContentTypes() {
+    return Object.entries(strapi.contentTypes).filter(([uid]) => uid.startsWith("api::")).map(([uid, ct]) => ({
+      uid,
+      displayName: ct.info?.displayName || uid,
+      kind: ct.kind
+    }));
+  }
+});
+const ENTRY_UID = "plugin::timeline.timeline-entry";
+const timelineService = ({ strapi }) => ({
+  async createSnapshot(params) {
+    try {
+      const result = await strapi.db.query(ENTRY_UID).create({
+        data: {
+          action: params.action,
+          contentType: params.contentType,
+          entryDocumentId: params.entryDocumentId,
+          content: params.content,
+          contentTypeSchema: params.contentTypeSchema || null,
+          userId: params.userId ? Number(params.userId) : null,
+          userName: params.userName || null,
+          locale: params.locale || null
+        }
+      });
+      strapi.log.info(
+        `[Timeline] Snapshot: ${params.action} on ${params.contentType} (doc: ${params.entryDocumentId})`
+      );
+      return result;
+    } catch (error) {
+      strapi.log.error(`[Timeline] Failed to create snapshot: ${error}`);
+      return null;
+    }
+  },
+  async findEntries(params) {
+    const {
+      contentType,
+      entryDocumentId,
+      userId,
+      action,
+      locale,
+      dateFrom,
+      dateTo,
+      sort = "createdAt",
+      sortOrder = "desc",
+      page = 1,
+      pageSize = 20
+    } = params;
+    const where = {};
+    if (contentType) {
+      const ctArr = Array.isArray(contentType) ? contentType : [contentType];
+      if (ctArr.length === 1) where.contentType = ctArr[0];
+      else if (ctArr.length > 1) where.contentType = { $in: ctArr };
+    }
+    if (entryDocumentId) where.entryDocumentId = entryDocumentId;
+    if (userId) {
+      const uArr = Array.isArray(userId) ? userId.map(Number) : [Number(userId)];
+      if (uArr.length === 1) where.userId = uArr[0];
+      else if (uArr.length > 1) where.userId = { $in: uArr };
+    }
+    if (action) {
+      const aArr = Array.isArray(action) ? action : [action];
+      if (aArr.length === 1) where.action = aArr[0];
+      else if (aArr.length > 1) where.action = { $in: aArr };
+    }
+    if (locale) {
+      const lArr = Array.isArray(locale) ? locale : [locale];
+      if (lArr.length === 1) where.locale = lArr[0];
+      else if (lArr.length > 1) where.locale = { $in: lArr };
+    }
+    if (dateFrom || dateTo) {
+      where.createdAt = {};
+      if (dateFrom) where.createdAt.$gte = new Date(dateFrom);
+      if (dateTo) {
+        const end = new Date(dateTo);
+        end.setHours(23, 59, 59, 999);
+        where.createdAt.$lte = end;
+      }
+    }
+    const allowedSortFields = ["createdAt", "action", "contentType", "userName"];
+    const sortField = allowedSortFields.includes(sort) ? sort : "createdAt";
+    const [entries, count] = await Promise.all([
+      strapi.db.query(ENTRY_UID).findMany({
+        where,
+        orderBy: { [sortField]: sortOrder },
+        offset: (page - 1) * pageSize,
+        limit: pageSize
+      }),
+      strapi.db.query(ENTRY_UID).count({ where })
+    ]);
+    return {
+      results: entries,
+      pagination: {
+        page,
+        pageSize,
+        total: count,
+        pageCount: Math.ceil(count / pageSize)
+      }
+    };
+  },
+  async getDistinctUsers() {
+    const knex = strapi.db.connection;
+    const rows = await knex("timeline_entries").select("user_id", "user_name").whereNotNull("user_id").groupBy("user_id", "user_name").orderBy("user_name", "asc");
+    return rows.map((r) => ({
+      userId: r.user_id,
+      userName: r.user_name || `User #${r.user_id}`
+    }));
+  },
+  async getDistinctLocales() {
+    const knex = strapi.db.connection;
+    const rows = await knex("timeline_entries").select("locale").whereNotNull("locale").where("locale", "!=", "").groupBy("locale").orderBy("locale", "asc");
+    return rows.map((r) => r.locale);
+  },
+  async findByDocumentId(contentType, entryDocumentId) {
+    return strapi.db.query(ENTRY_UID).findMany({
+      where: { contentType, entryDocumentId },
+      orderBy: { createdAt: "desc" }
+    });
+  },
+  async deleteAll() {
+    const knex = strapi.db.connection;
+    await knex("timeline_entries").delete();
+  },
+  async deleteByContentTypes(contentTypes2) {
+    if (!contentTypes2.length) return 0;
+    const knex = strapi.db.connection;
+    return knex("timeline_entries").whereIn("content_type", contentTypes2).delete();
+  },
+  async enforceEntriesLimit(contentType) {
+    try {
+      const settings = await strapi.plugin("timeline").service("settings").getSettings();
+      const config2 = settings.contentTypeConfigs?.[contentType];
+      if (!config2?.entriesLimit || config2.entriesLimit <= 0) return;
+      const count = await strapi.db.query(ENTRY_UID).count({ where: { contentType } });
+      if (count <= config2.entriesLimit) return;
+      const excess = count - config2.entriesLimit;
+      const oldEntries = await strapi.db.query(ENTRY_UID).findMany({
+        where: { contentType },
+        orderBy: { createdAt: "asc" },
+        limit: excess,
+        select: ["id"]
+      });
+      if (oldEntries.length > 0) {
+        const ids = oldEntries.map((e) => e.id);
+        await strapi.db.query(ENTRY_UID).deleteMany({ where: { id: { $in: ids } } });
+        strapi.log.info(`[Timeline] Enforced entries limit for ${contentType}: removed ${ids.length} old entries`);
+      }
+    } catch (error) {
+      strapi.log.error(`[Timeline] Failed to enforce entries limit: ${error}`);
+    }
+  },
+  async deleteByAge(contentType, cutoffDate) {
+    const knex = strapi.db.connection;
+    return knex("timeline_entries").where("content_type", contentType).where("created_at", "<", cutoffDate).delete();
+  }
+});
+const scheduleService = ({ strapi }) => ({
+  async getStatus() {
+    const settings = await strapi.plugin("timeline").service("settings").getSettings();
+    const contentTypeConfigs = settings.contentTypeConfigs || {};
+    const durationsConfigured = {};
+    for (const [uid, config2] of Object.entries(contentTypeConfigs)) {
+      if (config2.enabled && config2.durationLimit > 0) {
+        const ct = strapi.contentTypes[uid];
+        durationsConfigured[uid] = {
+          durationLimit: config2.durationLimit,
+          durationUnit: config2.durationUnit,
+          displayName: ct?.info?.displayName || uid
+        };
+      }
+    }
+    return {
+      cleanupEnabled: settings.cleanupEnabled,
+      cleanupCron: settings.cleanupCron,
+      lastCleanupAt: settings.lastCleanupAt,
+      lastCleanupResults: settings.lastCleanupResults,
+      durationsConfigured
+    };
+  },
+  async runCleanup() {
+    const settings = await strapi.plugin("timeline").service("settings").getSettings();
+    const configs = settings.contentTypeConfigs || {};
+    const results = {};
+    for (const [uid, config2] of Object.entries(configs)) {
+      if (!config2.enabled || !config2.durationLimit || config2.durationLimit <= 0) continue;
+      const cutoff = /* @__PURE__ */ new Date();
+      switch (config2.durationUnit) {
+        case "hours":
+          cutoff.setHours(cutoff.getHours() - config2.durationLimit);
+          break;
+        case "days":
+          cutoff.setDate(cutoff.getDate() - config2.durationLimit);
+          break;
+        case "weeks":
+          cutoff.setDate(cutoff.getDate() - config2.durationLimit * 7);
+          break;
+        case "months":
+          cutoff.setMonth(cutoff.getMonth() - config2.durationLimit);
+          break;
+        default:
+          continue;
+      }
+      const deleted = await strapi.plugin("timeline").service("timeline").deleteByAge(uid, cutoff);
+      if (deleted > 0) {
+        results[uid] = { deleted };
+      }
+    }
+    await strapi.plugin("timeline").service("settings").updateCleanupResults({
+      lastCleanupAt: (/* @__PURE__ */ new Date()).toISOString(),
+      lastCleanupResults: results
+    });
+    strapi.log.info(`[Timeline] Cleanup complete: ${JSON.stringify(results)}`);
+    return results;
+  }
+});
+const services = {
+  service,
+  settings: settingsService,
+  timeline: timelineService,
+  schedule: scheduleService
+};
+const index = {
+  register,
+  bootstrap,
+  destroy,
+  config,
+  controllers,
+  routes,
+  services,
+  contentTypes,
+  policies,
+  middlewares
+};
+export {
+  index as default
+};