@strapi/admin 5.0.0-beta.7 → 5.0.0-beta.9

package/dist/ee/server/index.js

@@ -1,5 +1,4 @@
 "use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const path = require("path");
 const fse = require("fs-extra");
 const koaStatic = require("koa-static");
@@ -7,16 +6,14 @@ const fp = require("lodash/fp");
 const dateFns = require("date-fns");
 const utils$1 = require("@strapi/utils");
 require("@strapi/types");
-const localProvider = require("@strapi/provider-audit-logs-local");
-const nodeSchedule = require("node-schedule");
 const _ = require("lodash");
 const passportLocal = require("passport-local");
 const passport$2 = require("koa-passport");
 const compose = require("koa-compose");
+const nodeSchedule = require("node-schedule");
 const _interopDefault = (e) => e && e.__esModule ? e : { default: e };
 const fse__default = /* @__PURE__ */ _interopDefault(fse);
 const koaStatic__default = /* @__PURE__ */ _interopDefault(koaStatic);
-const localProvider__default = /* @__PURE__ */ _interopDefault(localProvider);
 const ___default = /* @__PURE__ */ _interopDefault(_);
 const passport__default = /* @__PURE__ */ _interopDefault(passport$2);
 const compose__default = /* @__PURE__ */ _interopDefault(compose);
@@ -233,203 +230,9 @@ const executeCERegister = ({ strapi: strapi2 }) => {
     registerAdminPanelRoute({ strapi: strapi2 });
   }
 };
-async function migrateAuditLogsTable({ oldContentTypes, contentTypes }) {
-  const oldName = oldContentTypes?.["admin::audit-log"]?.collectionName;
-  const newName = contentTypes["admin::audit-log"]?.collectionName;
-  const hasRenamedAuditLogsTable = oldName === "audit_logs" && newName === "strapi_audit_logs";
-  if (!hasRenamedAuditLogsTable) {
-    return;
-  }
-  const hasAuditLogsTable = await strapi.db.getSchemaConnection().hasTable("audit_logs");
-  const hasLinkTable = await strapi.db.getSchemaConnection().hasTable("audit_logs_user_links");
-  if (!hasAuditLogsTable || !hasLinkTable) {
-    return;
-  }
-  const auditLogsColumnInfo = await strapi.db.connection("audit_logs").columnInfo();
-  const linkColumnInfo = await strapi.db.connection("audit_logs_user_links").columnInfo();
-  if (!auditLogsColumnInfo.action || !auditLogsColumnInfo.date || !auditLogsColumnInfo.payload || !linkColumnInfo.audit_log_id || !linkColumnInfo.user_id) {
-    return;
-  }
-  await strapi.db.getSchemaConnection().renameTable("audit_logs", "strapi_audit_logs");
-  await strapi.db.getSchemaConnection().renameTable("audit_logs_user_links", "strapi_audit_logs_user_links");
-}
-const DEFAULT_RETENTION_DAYS = 90;
-const defaultEvents = [
-  "entry.create",
-  "entry.update",
-  "entry.delete",
-  "entry.publish",
-  "entry.unpublish",
-  "media.create",
-  "media.update",
-  "media.delete",
-  "media-folder.create",
-  "media-folder.update",
-  "media-folder.delete",
-  "user.create",
-  "user.update",
-  "user.delete",
-  "admin.auth.success",
-  "admin.logout",
-  "content-type.create",
-  "content-type.update",
-  "content-type.delete",
-  "component.create",
-  "component.update",
-  "component.delete",
-  "role.create",
-  "role.update",
-  "role.delete",
-  "permission.create",
-  "permission.update",
-  "permission.delete"
-];
-const getSanitizedUser = (user2) => {
-  let displayName = user2.email;
-  if (user2.username) {
-    displayName = user2.username;
-  } else if (user2.firstname && user2.lastname) {
-    displayName = `${user2.firstname} ${user2.lastname}`;
-  }
-  return {
-    id: user2.id,
-    email: user2.email,
-    displayName
-  };
-};
-const getEventMap = (defaultEvents2) => {
-  const getDefaultPayload = (...args) => args[0];
-  return defaultEvents2.reduce((acc, event) => {
-    acc[event] = getDefaultPayload;
-    return acc;
-  }, {});
-};
-const getRetentionDays = (strapi2) => {
-  const licenseRetentionDays = strapi2.ee.features.get("audit-logs")?.options.retentionDays;
-  const userRetentionDays = strapi2.config.get("admin.auditLogs.retentionDays");
-  if (licenseRetentionDays == null) {
-    return userRetentionDays ?? DEFAULT_RETENTION_DAYS;
-  }
-  if (userRetentionDays && userRetentionDays < licenseRetentionDays) {
-    return userRetentionDays;
-  }
-  return licenseRetentionDays;
-};
-const createAuditLogsService = (strapi2) => {
-  const state = {};
-  const eventMap = getEventMap(defaultEvents);
-  const processEvent = (name2, ...args) => {
-    const requestState = strapi2.requestContext.get()?.state;
-    const isUsingAdminAuth = requestState?.auth?.strategy.name === "admin";
-    const user2 = requestState?.user;
-    if (!isUsingAdminAuth || !user2) {
-      return null;
-    }
-    const getPayload = eventMap[name2];
-    if (!getPayload) {
-      return null;
-    }
-    const ignoredUids = ["plugin::upload.file", "plugin::upload.folder"];
-    if (ignoredUids.includes(args[0]?.uid)) {
-      return null;
-    }
-    return {
-      action: name2,
-      date: (/* @__PURE__ */ new Date()).toISOString(),
-      payload: getPayload(...args) || {},
-      userId: user2.id
-    };
-  };
-  async function handleEvent(name2, ...args) {
-    const processedEvent = processEvent(name2, ...args);
-    if (processedEvent) {
-      await strapi2.db.transaction(({ onCommit }) => {
-        onCommit(() => state.provider.saveEvent(processedEvent));
-      });
-    }
-  }
-  return {
-    async register() {
-      if (!state.eeEnableUnsubscribe) {
-        state.eeEnableUnsubscribe = strapi2.eventHub.on("ee.enable", () => {
-          this.destroy();
-          this.register();
-        });
-      }
-      if (!state.eeUpdateUnsubscribe) {
-        state.eeUpdateUnsubscribe = strapi2.eventHub.on("ee.update", () => {
-          this.destroy();
-          this.register();
-        });
-      }
-      state.eeDisableUnsubscribe = strapi2.eventHub.on("ee.disable", () => {
-        this.destroy();
-      });
-      state.provider = await localProvider__default.default.register({ strapi: strapi2 });
-      if (!strapi2.ee.features.isEnabled("audit-logs")) {
-        return this;
-      }
-      state.eventHubUnsubscribe = strapi2.eventHub.subscribe(handleEvent.bind(this));
-      const retentionDays = getRetentionDays(strapi2);
-      state.deleteExpiredJob = nodeSchedule.scheduleJob("0 0 * * *", () => {
-        const expirationDate = new Date(Date.now() - retentionDays * 24 * 60 * 60 * 1e3);
-        state.provider.deleteExpiredEvents(expirationDate);
-      });
-      return this;
-    },
-    async findMany(query) {
-      const { results, pagination } = await state.provider.findMany(query);
-      const sanitizedResults = results.map((result) => {
-        const { user: user2, ...rest } = result;
-        return {
-          ...rest,
-          user: user2 ? getSanitizedUser(user2) : null
-        };
-      });
-      return {
-        results: sanitizedResults,
-        pagination
-      };
-    },
-    async findOne(id) {
-      const result = await state.provider.findOne(id);
-      if (!result) {
-        return null;
-      }
-      const { user: user2, ...rest } = result;
-      return {
-        ...rest,
-        user: user2 ? getSanitizedUser(user2) : null
-      };
-    },
-    unsubscribe() {
-      if (state.eeDisableUnsubscribe) {
-        state.eeDisableUnsubscribe();
-      }
-      if (state.eventHubUnsubscribe) {
-        state.eventHubUnsubscribe();
-      }
-      if (state.deleteExpiredJob) {
-        state.deleteExpiredJob.cancel();
-      }
-      return this;
-    },
-    destroy() {
-      return this.unsubscribe();
-    }
-  };
-};
 const register = async ({ strapi: strapi2 }) => {
-  const auditLogsIsEnabled = strapi2.config.get("admin.auditLogs.enabled", true);
-  if (auditLogsIsEnabled) {
-    strapi2.hook("strapi::content-types.beforeSync").register(migrateAuditLogsTable);
-    const auditLogsService = createAuditLogsService(strapi2);
-    strapi2.add("audit-logs", auditLogsService);
-    await auditLogsService.register();
-  }
   await executeCERegister({ strapi: strapi2 });
 };
-const index$3 = {};
 const actions$1 = [
   {
     uid: "marketplace.read",
@@ -736,7 +539,7 @@ const executeCEBootstrap = async ({ strapi: strapi2 }) => {
   await userService.displayWarningIfUsersDontHaveRole();
   await syncAuthSettings();
   await syncAPITokensPermissions();
-  getService$1("metrics").sendUpdateProjectInformation(strapi2);
+  await getService$1("metrics").sendUpdateProjectInformation(strapi2);
   getService$1("metrics").startCron(strapi2);
   apiTokenService.checkSaltIsDefined();
   transferService.token.checkSaltIsDefined();
@@ -834,222 +637,78 @@ const executeCEDestroy = async () => {
   await actionProvider.clear();
 };
 const destroy = async ({ strapi: strapi2 }) => {
-  if (strapi2.ee.features.isEnabled("audit-logs")) {
-    strapi2.get("audit-logs").destroy();
-  }
   await executeCEDestroy();
 };
-const enableFeatureMiddleware = (featureName) => (ctx, next) => {
-  if (strapi.ee.features.isEnabled(featureName)) {
-    return next();
+const adminContentTypes = {};
+const isSsoLocked = async (user2) => {
+  if (!strapi.ee.features.isEnabled("sso")) {
+    return false;
   }
-  ctx.status = 404;
+  if (!user2) {
+    throw new Error("Missing user object");
+  }
+  const adminStore = await strapi.store({ type: "core", name: "admin" });
+  const { providers } = await adminStore.get({ key: "auth" });
+  const lockedRoles = providers.ssoLockedRoles ?? [];
+  if (fp.isEmpty(lockedRoles)) {
+    return false;
+  }
+  const roles2 = (
+    // If the roles are pre-loaded for the given user, then use them
+    user2.roles ?? // Otherwise, try to load the role based on the given user ID
+    await strapi.db.query("admin::user").load(user2, "roles", { roles: { fields: ["id"] } }) ?? // If the query fails somehow, default to an empty array
+    []
+  );
+  const isLocked = lockedRoles.some(
+    (lockedId) => (
+      // lockedRoles will be a string to avoid issues with frontend and bigints
+      roles2.some((role2) => lockedId === role2.id.toString())
+    )
+  );
+  return isLocked;
 };
-const sso$1 = {
-  type: "admin",
-  routes: [
+const { ApplicationError: ApplicationError$2 } = utils$1.errors;
+const forgotPassword = async ({ email: email2 } = {}) => {
+  const user2 = await strapi.db.query("admin::user").findOne({ where: { email: email2, isActive: true } });
+  if (!user2 || await isSsoLocked(user2)) {
+    return;
+  }
+  const resetPasswordToken = getService("token").createToken();
+  await getService("user").updateById(user2.id, { resetPasswordToken });
+  const url = `${strapi.config.get(
+    "admin.absoluteUrl"
+  )}/auth/reset-password?code=${resetPasswordToken}`;
+  return strapi.plugin("email").service("email").sendTemplatedEmail(
     {
-      method: "GET",
-      path: "/providers",
-      handler: "authentication.getProviders",
-      config: {
-        middlewares: [enableFeatureMiddleware("sso")],
-        auth: false
-      }
+      to: user2.email,
+      from: strapi.config.get("admin.forgotPassword.from"),
+      replyTo: strapi.config.get("admin.forgotPassword.replyTo")
     },
+    strapi.config.get("admin.forgotPassword.emailTemplate"),
     {
-      method: "GET",
-      path: "/connect/:provider",
-      handler: "authentication.providerLogin",
-      config: {
-        middlewares: [enableFeatureMiddleware("sso")],
-        auth: false
-      }
-    },
-    {
-      method: "POST",
-      path: "/connect/:provider",
-      handler: "authentication.providerLogin",
-      config: {
-        middlewares: [enableFeatureMiddleware("sso")],
-        auth: false
-      }
-    },
-    {
-      method: "GET",
-      path: "/providers/options",
-      handler: "authentication.getProviderLoginOptions",
-      config: {
-        middlewares: [enableFeatureMiddleware("sso")],
-        policies: [
-          "admin::isAuthenticatedAdmin",
-          { name: "admin::hasPermissions", config: { actions: ["admin::provider-login.read"] } }
-        ]
-      }
-    },
-    {
-      method: "PUT",
-      path: "/providers/options",
-      handler: "authentication.updateProviderLoginOptions",
-      config: {
-        middlewares: [enableFeatureMiddleware("sso")],
-        policies: [
-          "admin::isAuthenticatedAdmin",
-          { name: "admin::hasPermissions", config: { actions: ["admin::provider-login.update"] } }
-        ]
-      }
-    },
-    {
-      method: "GET",
-      path: "/providers/isSSOLocked",
-      handler: "user.isSSOLocked",
-      config: {
-        middlewares: [enableFeatureMiddleware("sso")],
-        policies: ["admin::isAuthenticatedAdmin"]
-      }
-    }
-  ]
-};
-const licenseLimit = {
-  type: "admin",
-  routes: [
-    // License limit infos
-    {
-      method: "GET",
-      path: "/license-limit-information",
-      handler: "admin.licenseLimitInformation",
-      config: {
-        policies: [
-          "admin::isAuthenticatedAdmin",
-          {
-            name: "admin::hasPermissions",
-            config: {
-              actions: [
-                "admin::users.create",
-                "admin::users.read",
-                "admin::users.update",
-                "admin::users.delete"
-              ]
-            }
-          }
-        ]
-      }
-    }
-  ]
-};
-const auditLogs$1 = {
-  type: "admin",
-  routes: [
-    {
-      method: "GET",
-      path: "/audit-logs",
-      handler: "auditLogs.findMany",
-      config: {
-        middlewares: [enableFeatureMiddleware("audit-logs")],
-        policies: [
-          "admin::isAuthenticatedAdmin",
-          {
-            name: "admin::hasPermissions",
-            config: {
-              actions: ["admin::audit-logs.read"]
-            }
-          }
-        ]
-      }
-    },
-    {
-      method: "GET",
-      path: "/audit-logs/:id",
-      handler: "auditLogs.findOne",
-      config: {
-        middlewares: [enableFeatureMiddleware("audit-logs")],
-        policies: [
-          "admin::isAuthenticatedAdmin",
-          {
-            name: "admin::hasPermissions",
-            config: {
-              actions: ["admin::audit-logs.read"]
-            }
-          }
-        ]
-      }
-    }
-  ]
-};
-const index$2 = {
-  sso: sso$1,
-  "license-limit": licenseLimit,
-  "audit-logs": auditLogs$1
-};
-const isSsoLocked = async (user2) => {
-  if (!strapi.ee.features.isEnabled("sso")) {
-    return false;
-  }
-  if (!user2) {
-    throw new Error("Missing user object");
-  }
-  const adminStore = await strapi.store({ type: "core", name: "admin" });
-  const { providers } = await adminStore.get({ key: "auth" });
-  const lockedRoles = providers.ssoLockedRoles ?? [];
-  if (fp.isEmpty(lockedRoles)) {
-    return false;
-  }
-  const roles2 = (
-    // If the roles are pre-loaded for the given user, then use them
-    user2.roles ?? // Otherwise, try to load the role based on the given user ID
-    await strapi.db.query("admin::user").load(user2, "roles", { roles: { fields: ["id"] } }) ?? // If the query fails somehow, default to an empty array
-    []
-  );
-  const isLocked = lockedRoles.some(
-    (lockedId) => (
-      // lockedRoles will be a string to avoid issues with frontend and bigints
-      roles2.some((role2) => lockedId === role2.id.toString())
-    )
-  );
-  return isLocked;
-};
-const { ApplicationError: ApplicationError$2 } = utils$1.errors;
-const forgotPassword = async ({ email: email2 } = {}) => {
-  const user2 = await strapi.db.query("admin::user").findOne({ where: { email: email2, isActive: true } });
-  if (!user2 || await isSsoLocked(user2)) {
-    return;
-  }
-  const resetPasswordToken = getService("token").createToken();
-  await getService("user").updateById(user2.id, { resetPasswordToken });
-  const url = `${strapi.config.get(
-    "admin.absoluteUrl"
-  )}/auth/reset-password?code=${resetPasswordToken}`;
-  return strapi.plugin("email").service("email").sendTemplatedEmail(
-    {
-      to: user2.email,
-      from: strapi.config.get("admin.forgotPassword.from"),
-      replyTo: strapi.config.get("admin.forgotPassword.replyTo")
-    },
-    strapi.config.get("admin.forgotPassword.emailTemplate"),
-    {
-      url,
-      user: ___default.default.pick(user2, ["email", "firstname", "lastname", "username"])
-    }
-  ).catch((err) => {
-    strapi.log.error(err);
-  });
-};
-const resetPassword = async ({ resetPasswordToken, password: password2 } = {}) => {
-  const matchingUser = await strapi.db.query("admin::user").findOne({ where: { resetPasswordToken, isActive: true } });
-  if (!matchingUser || await isSsoLocked(matchingUser)) {
-    throw new ApplicationError$2();
-  }
-  return getService("user").updateById(matchingUser.id, {
-    password: password2,
-    resetPasswordToken: null
-  });
-};
-const auth = {
-  forgotPassword,
-  resetPassword
-};
-const createLocalStrategy = (strapi2, middleware) => {
-  return new passportLocal.Strategy(
+      url,
+      user: ___default.default.pick(user2, ["email", "firstname", "lastname", "username"])
+    }
+  ).catch((err) => {
+    strapi.log.error(err);
+  });
+};
+const resetPassword = async ({ resetPasswordToken, password: password2 } = {}) => {
+  const matchingUser = await strapi.db.query("admin::user").findOne({ where: { resetPasswordToken, isActive: true } });
+  if (!matchingUser || await isSsoLocked(matchingUser)) {
+    throw new ApplicationError$2();
+  }
+  return getService("user").updateById(matchingUser.id, {
+    password: password2,
+    resetPasswordToken: null
+  });
+};
+const auth = {
+  forgotPassword,
+  resetPassword
+};
+const createLocalStrategy = (strapi2, middleware) => {
+  return new passportLocal.Strategy(
     {
       usernameField: "email",
       passwordField: "password",
@@ -1126,7 +785,7 @@ const syncProviderRegistryWithConfig = () => {
 const SSOAuthEventsMapper = {
   onSSOAutoRegistration: "admin.auth.autoRegistration"
 };
-const sso = {
+const sso$1 = {
   providerRegistry,
   getStrategyCallbackURL,
   syncProviderRegistryWithConfig,
@@ -1151,15 +810,15 @@ const getPassportStrategies = () => {
   }
   const localStrategy = createLocalStrategy(strapi, localStrategyMiddleware);
   if (!strapi.isLoaded) {
-    sso.syncProviderRegistryWithConfig();
+    sso$1.syncProviderRegistryWithConfig();
   }
-  const providers = sso.providerRegistry.getAll();
+  const providers = sso$1.providerRegistry.getAll();
   const strategies = providers.map((provider) => provider.createStrategy(strapi));
   return [localStrategy, ...strategies];
 };
 const passport = {
   getPassportStrategies,
-  ...sso
+  ...sso$1
 };
 const { ApplicationError: ApplicationError$1 } = utils$1.errors;
 const ssoCheckRolesIdForDeletion = async (ids) => {
@@ -1350,7 +1009,7 @@ const sendUpdateProjectInformation = async (strapi2) => {
   if (strapi2.ee.features.isEnabled("cms-content-releases")) {
     const numberOfContentReleases = await strapi2.db.query("plugin::content-releases.release").count();
     const numberOfPublishedContentReleases = await strapi2.db.query("plugin::content-releases.release").count({
-      where: { $not: { releasedAt: null } }
+      filters: { releasedAt: { $notNull: true } }
     });
     groupProperties = fp.assign(groupProperties, {
       numberOfContentReleases,
@@ -1450,7 +1109,7 @@ const seatEnforcement = {
   seatEnforcementWorkflow,
   getDisabledUserList
 };
-const index$1 = {
+const services = {
   auth,
   passport,
   role: role$1,
@@ -2031,29 +1690,6 @@ const user = {
     };
   }
 };
-const ALLOWED_SORT_STRINGS = ["action:ASC", "action:DESC", "date:ASC", "date:DESC"];
-const validateFindManySchema = utils$1.yup.object().shape({
-  page: utils$1.yup.number().integer().min(1),
-  pageSize: utils$1.yup.number().integer().min(1).max(100),
-  sort: utils$1.yup.mixed().oneOf(ALLOWED_SORT_STRINGS)
-}).required();
-const validateFindMany = utils$1.validateYupSchema(validateFindManySchema, { strict: false });
-const auditLogs = {
-  async findMany(ctx) {
-    const { query } = ctx.request;
-    await validateFindMany(query);
-    const auditLogs2 = strapi.get("audit-logs");
-    const body = await auditLogs2.findMany(query);
-    ctx.body = body;
-  },
-  async findOne(ctx) {
-    const { id } = ctx.params;
-    const auditLogs2 = strapi.get("audit-logs");
-    const body = await auditLogs2.findOne(id);
-    ctx.body = body;
-    strapi.telemetry.send("didWatchAnAuditLog");
-  }
-};
 const admin = {
   // NOTE: Overrides CE admin controller
   async getProjectType() {
@@ -2097,18 +1733,450 @@ const admin = {
     return { data };
   }
 };
-const index = {
+const controllers = {
   authentication,
   role,
   user,
-  auditLogs,
   admin
 };
-exports.bootstrap = bootstrap;
-exports.contentTypes = index$3;
-exports.controllers = index;
-exports.destroy = destroy;
-exports.register = register;
-exports.routes = index$2;
-exports.services = index$1;
+const enableFeatureMiddleware = (featureName) => (ctx, next) => {
+  if (strapi.ee.features.isEnabled(featureName)) {
+    return next();
+  }
+  ctx.status = 404;
+};
+const sso = {
+  type: "admin",
+  routes: [
+    {
+      method: "GET",
+      path: "/providers",
+      handler: "authentication.getProviders",
+      config: {
+        middlewares: [enableFeatureMiddleware("sso")],
+        auth: false
+      }
+    },
+    {
+      method: "GET",
+      path: "/connect/:provider",
+      handler: "authentication.providerLogin",
+      config: {
+        middlewares: [enableFeatureMiddleware("sso")],
+        auth: false
+      }
+    },
+    {
+      method: "POST",
+      path: "/connect/:provider",
+      handler: "authentication.providerLogin",
+      config: {
+        middlewares: [enableFeatureMiddleware("sso")],
+        auth: false
+      }
+    },
+    {
+      method: "GET",
+      path: "/providers/options",
+      handler: "authentication.getProviderLoginOptions",
+      config: {
+        middlewares: [enableFeatureMiddleware("sso")],
+        policies: [
+          "admin::isAuthenticatedAdmin",
+          { name: "admin::hasPermissions", config: { actions: ["admin::provider-login.read"] } }
+        ]
+      }
+    },
+    {
+      method: "PUT",
+      path: "/providers/options",
+      handler: "authentication.updateProviderLoginOptions",
+      config: {
+        middlewares: [enableFeatureMiddleware("sso")],
+        policies: [
+          "admin::isAuthenticatedAdmin",
+          { name: "admin::hasPermissions", config: { actions: ["admin::provider-login.update"] } }
+        ]
+      }
+    },
+    {
+      method: "GET",
+      path: "/providers/isSSOLocked",
+      handler: "user.isSSOLocked",
+      config: {
+        middlewares: [enableFeatureMiddleware("sso")],
+        policies: ["admin::isAuthenticatedAdmin"]
+      }
+    }
+  ]
+};
+const licenseLimit = {
+  type: "admin",
+  routes: [
+    // License limit infos
+    {
+      method: "GET",
+      path: "/license-limit-information",
+      handler: "admin.licenseLimitInformation",
+      config: {
+        policies: [
+          "admin::isAuthenticatedAdmin",
+          {
+            name: "admin::hasPermissions",
+            config: {
+              actions: [
+                "admin::users.create",
+                "admin::users.read",
+                "admin::users.update",
+                "admin::users.delete"
+              ]
+            }
+          }
+        ]
+      }
+    }
+  ]
+};
+const routes = {
+  sso,
+  "license-limit": licenseLimit
+};
+const auditLogsRoutes = {
+  type: "admin",
+  routes: [
+    {
+      method: "GET",
+      path: "/audit-logs",
+      handler: "audit-logs.findMany",
+      config: {
+        middlewares: [enableFeatureMiddleware("audit-logs")],
+        policies: [
+          "admin::isAuthenticatedAdmin",
+          {
+            name: "admin::hasPermissions",
+            config: {
+              actions: ["admin::audit-logs.read"]
+            }
+          }
+        ]
+      }
+    },
+    {
+      method: "GET",
+      path: "/audit-logs/:id",
+      handler: "audit-logs.findOne",
+      config: {
+        middlewares: [enableFeatureMiddleware("audit-logs")],
+        policies: [
+          "admin::isAuthenticatedAdmin",
+          {
+            name: "admin::hasPermissions",
+            config: {
+              actions: ["admin::audit-logs.read"]
+            }
+          }
+        ]
+      }
+    }
+  ]
+};
+const ALLOWED_SORT_STRINGS = ["action:ASC", "action:DESC", "date:ASC", "date:DESC"];
+const validateFindManySchema = utils$1.yup.object().shape({
+  page: utils$1.yup.number().integer().min(1),
+  pageSize: utils$1.yup.number().integer().min(1).max(100),
+  sort: utils$1.yup.mixed().oneOf(ALLOWED_SORT_STRINGS)
+}).required();
+const validateFindMany = utils$1.validateYupSchema(validateFindManySchema, { strict: false });
+const auditLogsController = {
+  async findMany(ctx) {
+    const { query } = ctx.request;
+    await validateFindMany(query);
+    const auditLogs = strapi.get("audit-logs");
+    const body = await auditLogs.findMany(query);
+    ctx.body = body;
+  },
+  async findOne(ctx) {
+    const { id } = ctx.params;
+    const auditLogs = strapi.get("audit-logs");
+    const body = await auditLogs.findOne(id);
+    ctx.body = body;
+    strapi.telemetry.send("didWatchAnAuditLog");
+  }
+};
+const getSanitizedUser = (user2) => {
+  let displayName = user2.email;
+  if (user2.username) {
+    displayName = user2.username;
+  } else if (user2.firstname && user2.lastname) {
+    displayName = `${user2.firstname} ${user2.lastname}`;
+  }
+  return {
+    id: user2.id,
+    email: user2.email,
+    displayName
+  };
+};
+const createAuditLogsService = (strapi2) => {
+  return {
+    async saveEvent(event) {
+      const { userId, ...rest } = event;
+      const auditLog2 = { ...rest, user: userId };
+      await strapi2.db?.query("admin::audit-log").create({ data: auditLog2 });
+      return this;
+    },
+    async findMany(query) {
+      const { results, pagination } = await strapi2.db?.query("admin::audit-log").findPage({
+        populate: ["user"],
+        select: ["action", "date", "payload"],
+        ...strapi2.get("query-params").transform("admin::audit-log", query)
+      });
+      const sanitizedResults = results.map((result) => {
+        const { user: user2, ...rest } = result;
+        return {
+          ...rest,
+          user: user2 ? getSanitizedUser(user2) : null
+        };
+      });
+      return {
+        results: sanitizedResults,
+        pagination
+      };
+    },
+    async findOne(id) {
+      const result = await strapi2.db?.query("admin::audit-log").findOne({
+        where: { id },
+        populate: ["user"],
+        select: ["action", "date", "payload"]
+      });
+      if (!result) {
+        return null;
+      }
+      const { user: user2, ...rest } = result;
+      return {
+        ...rest,
+        user: user2 ? getSanitizedUser(user2) : null
+      };
+    },
+    deleteExpiredEvents(expirationDate) {
+      return strapi2.db?.query("admin::audit-log").deleteMany({
+        where: {
+          date: {
+            $lt: expirationDate.toISOString()
+          }
+        }
+      });
+    }
+  };
+};
+const DEFAULT_RETENTION_DAYS = 90;
+const defaultEvents = [
+  "entry.create",
+  "entry.update",
+  "entry.delete",
+  "entry.publish",
+  "entry.unpublish",
+  "media.create",
+  "media.update",
+  "media.delete",
+  "media-folder.create",
+  "media-folder.update",
+  "media-folder.delete",
+  "user.create",
+  "user.update",
+  "user.delete",
+  "admin.auth.success",
+  "admin.logout",
+  "content-type.create",
+  "content-type.update",
+  "content-type.delete",
+  "component.create",
+  "component.update",
+  "component.delete",
+  "role.create",
+  "role.update",
+  "role.delete",
+  "permission.create",
+  "permission.update",
+  "permission.delete"
+];
+const getEventMap = (defaultEvents2) => {
+  const getDefaultPayload = (...args) => args[0];
+  return defaultEvents2.reduce((acc, event) => {
+    acc[event] = getDefaultPayload;
+    return acc;
+  }, {});
+};
+const getRetentionDays = (strapi2) => {
+  const featureConfig = strapi2.ee.features.get("audit-logs");
+  const licenseRetentionDays = typeof featureConfig === "object" && featureConfig?.options.retentionDays;
+  const userRetentionDays = strapi2.config.get("admin.auditLogs.retentionDays");
+  if (licenseRetentionDays == null) {
+    return userRetentionDays ?? DEFAULT_RETENTION_DAYS;
+  }
+  if (userRetentionDays && userRetentionDays < licenseRetentionDays) {
+    return userRetentionDays;
+  }
+  return licenseRetentionDays;
+};
+const createAuditLogsLifecycleService = (strapi2) => {
+  const state = {};
+  const auditLogsService = strapi2.get("audit-logs");
+  const eventMap = getEventMap(defaultEvents);
+  const processEvent = (name2, ...args) => {
+    const requestState = strapi2.requestContext.get()?.state;
+    const isUsingAdminAuth = requestState?.route.info.type === "admin";
+    const user2 = requestState?.user;
+    if (!isUsingAdminAuth || !user2) {
+      return null;
+    }
+    const getPayload = eventMap[name2];
+    if (!getPayload) {
+      return null;
+    }
+    const ignoredUids = ["plugin::upload.file", "plugin::upload.folder"];
+    if (ignoredUids.includes(args[0]?.uid)) {
+      return null;
+    }
+    return {
+      action: name2,
+      date: (/* @__PURE__ */ new Date()).toISOString(),
+      payload: getPayload(...args) || {},
+      userId: user2.id
+    };
+  };
+  const handleEvent = async (name2, ...args) => {
+    const processedEvent = processEvent(name2, ...args);
+    if (processedEvent) {
+      await strapi2.db.transaction(({ onCommit }) => {
+        onCommit(() => auditLogsService.saveEvent(processedEvent));
+      });
+    }
+  };
+  return {
+    async register() {
+      if (!state.eeEnableUnsubscribe) {
+        state.eeEnableUnsubscribe = strapi2.eventHub.on("ee.enable", () => {
+          this.destroy();
+          this.register();
+        });
+      }
+      if (!state.eeUpdateUnsubscribe) {
+        state.eeUpdateUnsubscribe = strapi2.eventHub.on("ee.update", () => {
+          this.destroy();
+          this.register();
+        });
+      }
+      state.eeDisableUnsubscribe = strapi2.eventHub.on("ee.disable", () => {
+        this.destroy();
+      });
+      if (!strapi2.ee.features.isEnabled("audit-logs")) {
+        return this;
+      }
+      state.eventHubUnsubscribe = strapi2.eventHub.subscribe(handleEvent);
+      const retentionDays = getRetentionDays(strapi2);
+      state.deleteExpiredJob = nodeSchedule.scheduleJob("0 0 * * *", () => {
+        const expirationDate = new Date(Date.now() - retentionDays * 24 * 60 * 60 * 1e3);
+        auditLogsService.deleteExpiredEvents(expirationDate);
+      });
+      return this;
+    },
+    unsubscribe() {
+      if (state.eeDisableUnsubscribe) {
+        state.eeDisableUnsubscribe();
+      }
+      if (state.eventHubUnsubscribe) {
+        state.eventHubUnsubscribe();
+      }
+      if (state.deleteExpiredJob) {
+        state.deleteExpiredJob.cancel();
+      }
+      return this;
+    },
+    destroy() {
+      return this.unsubscribe();
+    }
+  };
+};
+const auditLog = {
+  schema: {
+    kind: "collectionType",
+    collectionName: "strapi_audit_logs",
+    info: {
+      singularName: "audit-log",
+      pluralName: "audit-logs",
+      displayName: "Audit Log"
+    },
+    options: {
+      timestamps: false
+    },
+    pluginOptions: {
+      "content-manager": {
+        visible: false
+      },
+      "content-type-builder": {
+        visible: false
+      }
+    },
+    attributes: {
+      action: {
+        type: "string",
+        required: true
+      },
+      date: {
+        type: "datetime",
+        required: true
+      },
+      user: {
+        type: "relation",
+        relation: "oneToOne",
+        target: "admin::user"
+      },
+      payload: {
+        type: "json"
+      }
+    }
+  }
+};
+const getAdminEE = () => {
+  const eeAdmin = {
+    register,
+    bootstrap,
+    destroy,
+    contentTypes: {
+      // Always register the audit-log content type to prevent data loss
+      "audit-log": auditLog,
+      ...adminContentTypes
+    },
+    services,
+    controllers,
+    routes
+  };
+  if (strapi.config.get("admin.auditLogs.enabled", true) && strapi.ee.features.isEnabled("audit-logs")) {
+    return {
+      ...eeAdmin,
+      controllers: {
+        ...eeAdmin.controllers,
+        "audit-logs": auditLogsController
+      },
+      routes: {
+        ...eeAdmin.routes,
+        "audit-logs": auditLogsRoutes
+      },
+      async register({ strapi: strapi2 }) {
+        await eeAdmin.register({ strapi: strapi2 });
+        strapi2.add("audit-logs", createAuditLogsService(strapi2));
+        const auditLogsLifecycle = createAuditLogsLifecycleService(strapi2);
+        strapi2.add("audit-logs-lifecycle", auditLogsLifecycle);
+        await auditLogsLifecycle.register();
+      },
+      async destroy({ strapi: strapi2 }) {
+        strapi2.get("audit-logs-lifecycle").destroy();
+        await eeAdmin.destroy({ strapi: strapi2 });
+      }
+    };
+  }
+  return eeAdmin;
+};
+const index = getAdminEE();
+module.exports = index;
 //# sourceMappingURL=index.js.map