@strapi/admin 5.0.0-rc.9 → 5.0.0

package/dist/ee/server/index.js

@@ -1,2193 +0,0 @@
-"use strict";
-const path = require("path");
-const fse = require("fs-extra");
-const koaStatic = require("koa-static");
-const fp = require("lodash/fp");
-const dateFns = require("date-fns");
-const utils$1 = require("@strapi/utils");
-require("@strapi/types");
-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 ___default = /* @__PURE__ */ _interopDefault(_);
-const passport__default = /* @__PURE__ */ _interopDefault(passport$2);
-const compose__default = /* @__PURE__ */ _interopDefault(compose);
-const registerAdminPanelRoute = ({ strapi: strapi2 }) => {
-  let buildDir = path.resolve(strapi2.dirs.dist.root, "build");
-  if (!fse__default.default.pathExistsSync(buildDir)) {
-    buildDir = path.resolve(__dirname, "../../build");
-  }
-  const serveAdminMiddleware = async (ctx, next) => {
-    await next();
-    if (ctx.method !== "HEAD" && ctx.method !== "GET") {
-      return;
-    }
-    if (ctx.body != null || ctx.status !== 404) {
-      return;
-    }
-    ctx.type = "html";
-    ctx.body = fse__default.default.createReadStream(path.join(buildDir, "index.html"));
-  };
-  strapi2.server.routes([
-    {
-      method: "GET",
-      path: `${strapi2.config.admin.path}/:path*`,
-      handler: [
-        serveAdminMiddleware,
-        serveStatic(buildDir, {
-          maxage: 31536e3,
-          defer: false,
-          index: "index.html",
-          setHeaders(res, path$1) {
-            const ext = path.extname(path$1);
-            if (ext !== ".html") {
-              res.setHeader("cache-control", "public, max-age=31536000, immutable");
-            }
-          }
-        })
-      ],
-      config: { auth: false }
-    }
-  ]);
-};
-const serveStatic = (filesDir, koaStaticOptions = {}) => {
-  const serve = koaStatic__default.default(filesDir, koaStaticOptions);
-  return async (ctx, next) => {
-    const prev = ctx.path;
-    const newPath = path.basename(ctx.path);
-    ctx.path = newPath;
-    await serve(ctx, async () => {
-      ctx.path = prev;
-      await next();
-      ctx.path = newPath;
-    });
-    ctx.path = prev;
-  };
-};
-const getService$1 = (name2) => {
-  return strapi.service(`admin::${name2}`);
-};
-const authenticate$2 = async (ctx) => {
-  const { authorization } = ctx.request.header;
-  if (!authorization) {
-    return { authenticated: false };
-  }
-  const parts = authorization.split(/\s+/);
-  if (parts[0].toLowerCase() !== "bearer" || parts.length !== 2) {
-    return { authenticated: false };
-  }
-  const token = parts[1];
-  const { payload, isValid } = getService$1("token").decodeJwtToken(token);
-  if (!isValid) {
-    return { authenticated: false };
-  }
-  const user2 = await strapi.db.query("admin::user").findOne({ where: { id: payload.id }, populate: ["roles"] });
-  if (!user2 || !(user2.isActive === true)) {
-    return { authenticated: false };
-  }
-  const userAbility = await getService$1("permission").engine.generateUserAbility(user2);
-  ctx.state.userAbility = userAbility;
-  ctx.state.user = user2;
-  return {
-    authenticated: true,
-    credentials: user2,
-    ability: userAbility
-  };
-};
-const name = "admin";
-const adminAuthStrategy = {
-  name,
-  authenticate: authenticate$2
-};
-const DAY_IN_MS = 24 * 60 * 60 * 1e3;
-const constants = {
-  CONTENT_TYPE_SECTION: "contentTypes",
-  SUPER_ADMIN_CODE: "strapi-super-admin",
-  EDITOR_CODE: "strapi-editor",
-  AUTHOR_CODE: "strapi-author",
-  READ_ACTION: "plugin::content-manager.explorer.read",
-  CREATE_ACTION: "plugin::content-manager.explorer.create",
-  UPDATE_ACTION: "plugin::content-manager.explorer.update",
-  DELETE_ACTION: "plugin::content-manager.explorer.delete",
-  PUBLISH_ACTION: "plugin::content-manager.explorer.publish",
-  API_TOKEN_TYPE: {
-    READ_ONLY: "read-only",
-    FULL_ACCESS: "full-access",
-    CUSTOM: "custom"
-  },
-  // The front-end only displays these values
-  API_TOKEN_LIFESPANS: {
-    UNLIMITED: null,
-    DAYS_7: 7 * DAY_IN_MS,
-    DAYS_30: 30 * DAY_IN_MS,
-    DAYS_90: 90 * DAY_IN_MS
-  },
-  TRANSFER_TOKEN_TYPE: {
-    PUSH: "push",
-    PULL: "pull"
-  },
-  TRANSFER_TOKEN_LIFESPANS: {
-    UNLIMITED: null,
-    DAYS_7: 7 * DAY_IN_MS,
-    DAYS_30: 30 * DAY_IN_MS,
-    DAYS_90: 90 * DAY_IN_MS
-  }
-};
-const { UnauthorizedError: UnauthorizedError$1, ForbiddenError: ForbiddenError$1 } = utils$1.errors;
-const isReadScope = (scope) => scope.endsWith("find") || scope.endsWith("findOne");
-const extractToken = (ctx) => {
-  if (ctx.request && ctx.request.header && ctx.request.header.authorization) {
-    const parts = ctx.request.header.authorization.split(/\s+/);
-    if (parts[0].toLowerCase() !== "bearer" || parts.length !== 2) {
-      return null;
-    }
-    return parts[1];
-  }
-  return null;
-};
-const authenticate$1 = async (ctx) => {
-  const apiTokenService = getService$1("api-token");
-  const token = extractToken(ctx);
-  if (!token) {
-    return { authenticated: false };
-  }
-  const apiToken = await apiTokenService.getBy({
-    accessKey: apiTokenService.hash(token)
-  });
-  if (!apiToken) {
-    return { authenticated: false };
-  }
-  const currentDate = /* @__PURE__ */ new Date();
-  if (!fp.isNil(apiToken.expiresAt)) {
-    const expirationDate = new Date(apiToken.expiresAt);
-    if (expirationDate < currentDate) {
-      return { authenticated: false, error: new UnauthorizedError$1("Token expired") };
-    }
-  }
-  const hoursSinceLastUsed = dateFns.differenceInHours(currentDate, dateFns.parseISO(apiToken.lastUsedAt));
-  if (hoursSinceLastUsed >= 1) {
-    await strapi.db.query("admin::api-token").update({
-      where: { id: apiToken.id },
-      data: { lastUsedAt: currentDate }
-    });
-  }
-  if (apiToken.type === constants.API_TOKEN_TYPE.CUSTOM) {
-    const ability = await strapi.contentAPI.permissions.engine.generateAbility(
-      apiToken.permissions.map((action) => ({ action }))
-    );
-    return { authenticated: true, ability, credentials: apiToken };
-  }
-  return { authenticated: true, credentials: apiToken };
-};
-const verify = (auth2, config) => {
-  const { credentials: apiToken, ability } = auth2;
-  if (!apiToken) {
-    throw new UnauthorizedError$1("Token not found");
-  }
-  const currentDate = /* @__PURE__ */ new Date();
-  if (!fp.isNil(apiToken.expiresAt)) {
-    const expirationDate = new Date(apiToken.expiresAt);
-    if (expirationDate < currentDate) {
-      throw new UnauthorizedError$1("Token expired");
-    }
-  }
-  if (apiToken.type === constants.API_TOKEN_TYPE.FULL_ACCESS) {
-    return;
-  }
-  if (apiToken.type === constants.API_TOKEN_TYPE.READ_ONLY) {
-    const scopes = fp.castArray(config.scope);
-    if (config.scope && scopes.every(isReadScope)) {
-      return;
-    }
-  } else if (apiToken.type === constants.API_TOKEN_TYPE.CUSTOM) {
-    if (!ability) {
-      throw new ForbiddenError$1();
-    }
-    const scopes = fp.castArray(config.scope);
-    const isAllowed = scopes.every((scope) => ability.can(scope));
-    if (isAllowed) {
-      return;
-    }
-  }
-  throw new ForbiddenError$1();
-};
-const apiTokenAuthStrategy = {
-  name: "api-token",
-  authenticate: authenticate$1,
-  verify
-};
-const executeCERegister = ({ strapi: strapi2 }) => {
-  const passportMiddleware = strapi2.service("admin::passport").init();
-  strapi2.server.api("admin").use(passportMiddleware);
-  strapi2.get("auth").register("admin", adminAuthStrategy);
-  strapi2.get("auth").register("content-api", apiTokenAuthStrategy);
-  if (strapi2.config.get("admin.serveAdminPanel")) {
-    registerAdminPanelRoute({ strapi: strapi2 });
-  }
-};
-const register = async ({ strapi: strapi2 }) => {
-  await executeCERegister({ strapi: strapi2 });
-};
-const actions$1 = [
-  {
-    uid: "marketplace.read",
-    displayName: "Access the marketplace",
-    pluginName: "admin",
-    section: "settings",
-    category: "plugins and marketplace",
-    subCategory: "marketplace"
-  },
-  {
-    uid: "webhooks.create",
-    displayName: "Create",
-    pluginName: "admin",
-    section: "settings",
-    category: "webhooks"
-  },
-  {
-    uid: "webhooks.read",
-    displayName: "Read",
-    pluginName: "admin",
-    section: "settings",
-    category: "webhooks"
-  },
-  {
-    uid: "webhooks.update",
-    displayName: "Update",
-    pluginName: "admin",
-    section: "settings",
-    category: "webhooks"
-  },
-  {
-    uid: "webhooks.delete",
-    displayName: "Delete",
-    pluginName: "admin",
-    section: "settings",
-    category: "webhooks"
-  },
-  {
-    uid: "users.create",
-    displayName: "Create (invite)",
-    pluginName: "admin",
-    section: "settings",
-    category: "users and roles",
-    subCategory: "users"
-  },
-  {
-    uid: "users.read",
-    displayName: "Read",
-    pluginName: "admin",
-    section: "settings",
-    category: "users and roles",
-    subCategory: "users",
-    aliases: [
-      {
-        actionId: "plugin::content-manager.explorer.read",
-        subjects: ["admin::user"]
-      }
-    ]
-  },
-  {
-    uid: "users.update",
-    displayName: "Update",
-    pluginName: "admin",
-    section: "settings",
-    category: "users and roles",
-    subCategory: "users"
-  },
-  {
-    uid: "users.delete",
-    displayName: "Delete",
-    pluginName: "admin",
-    section: "settings",
-    category: "users and roles",
-    subCategory: "users"
-  },
-  {
-    uid: "roles.create",
-    displayName: "Create",
-    pluginName: "admin",
-    section: "settings",
-    category: "users and roles",
-    subCategory: "roles"
-  },
-  {
-    uid: "roles.read",
-    displayName: "Read",
-    pluginName: "admin",
-    section: "settings",
-    category: "users and roles",
-    subCategory: "roles",
-    aliases: [
-      {
-        actionId: "plugin::content-manager.explorer.read",
-        subjects: ["admin::role"]
-      }
-    ]
-  },
-  {
-    uid: "roles.update",
-    displayName: "Update",
-    pluginName: "admin",
-    section: "settings",
-    category: "users and roles",
-    subCategory: "roles"
-  },
-  {
-    uid: "roles.delete",
-    displayName: "Delete",
-    pluginName: "admin",
-    section: "settings",
-    category: "users and roles",
-    subCategory: "roles"
-  },
-  {
-    uid: "api-tokens.access",
-    displayName: "Access the API tokens settings page",
-    pluginName: "admin",
-    section: "settings",
-    category: "api tokens",
-    subCategory: "api Tokens"
-  },
-  {
-    uid: "api-tokens.create",
-    displayName: "Create (generate)",
-    pluginName: "admin",
-    section: "settings",
-    category: "api tokens",
-    subCategory: "general"
-  },
-  {
-    uid: "api-tokens.read",
-    displayName: "Read",
-    pluginName: "admin",
-    section: "settings",
-    category: "api tokens",
-    subCategory: "general"
-  },
-  {
-    uid: "api-tokens.update",
-    displayName: "Update",
-    pluginName: "admin",
-    section: "settings",
-    category: "api tokens",
-    subCategory: "general"
-  },
-  {
-    uid: "api-tokens.regenerate",
-    displayName: "Regenerate",
-    pluginName: "admin",
-    section: "settings",
-    category: "api tokens",
-    subCategory: "general"
-  },
-  {
-    uid: "api-tokens.delete",
-    displayName: "Delete (revoke)",
-    pluginName: "admin",
-    section: "settings",
-    category: "api tokens",
-    subCategory: "general"
-  },
-  {
-    uid: "project-settings.update",
-    displayName: "Update the project level settings",
-    pluginName: "admin",
-    section: "settings",
-    category: "project"
-  },
-  {
-    uid: "project-settings.read",
-    displayName: "Read the project level settings",
-    pluginName: "admin",
-    section: "settings",
-    category: "project"
-  },
-  {
-    uid: "transfer.tokens.access",
-    displayName: "Access the transfer tokens settings page",
-    pluginName: "admin",
-    section: "settings",
-    category: "transfer tokens",
-    subCategory: "transfer tokens"
-  },
-  {
-    uid: "transfer.tokens.create",
-    displayName: "Create (generate)",
-    pluginName: "admin",
-    section: "settings",
-    category: "transfer tokens",
-    subCategory: "general"
-  },
-  {
-    uid: "transfer.tokens.read",
-    displayName: "Read",
-    pluginName: "admin",
-    section: "settings",
-    category: "transfer tokens",
-    subCategory: "general"
-  },
-  {
-    uid: "transfer.tokens.update",
-    displayName: "Update",
-    pluginName: "admin",
-    section: "settings",
-    category: "transfer tokens",
-    subCategory: "general"
-  },
-  {
-    uid: "transfer.tokens.regenerate",
-    displayName: "Regenerate",
-    pluginName: "admin",
-    section: "settings",
-    category: "transfer tokens",
-    subCategory: "general"
-  },
-  {
-    uid: "transfer.tokens.delete",
-    displayName: "Delete (revoke)",
-    pluginName: "admin",
-    section: "settings",
-    category: "transfer tokens",
-    subCategory: "general"
-  }
-];
-const adminActions = {
-  actions: actions$1
-};
-const conditions = [
-  {
-    displayName: "Is creator",
-    name: "is-creator",
-    plugin: "admin",
-    handler: (user2) => ({ "createdBy.id": user2.id })
-  },
-  {
-    displayName: "Has same role as creator",
-    name: "has-same-role-as-creator",
-    plugin: "admin",
-    handler: (user2) => ({
-      "createdBy.roles": {
-        $elemMatch: {
-          id: {
-            $in: user2.roles.map((r) => r.id)
-          }
-        }
-      }
-    })
-  }
-];
-const adminConditions = {
-  conditions
-};
-const defaultAdminAuthSettings = {
-  providers: {
-    autoRegister: false,
-    defaultRole: null,
-    ssoLockedRoles: null
-  }
-};
-const registerPermissionActions = async () => {
-  await getService$1("permission").actionProvider.registerMany(adminActions.actions);
-};
-const registerAdminConditions = async () => {
-  await getService$1("permission").conditionProvider.registerMany(adminConditions.conditions);
-};
-const registerModelHooks = () => {
-  const { sendDidChangeInterfaceLanguage } = getService$1("metrics");
-  strapi.db.lifecycles.subscribe({
-    models: ["admin::user"],
-    afterCreate: sendDidChangeInterfaceLanguage,
-    afterDelete: sendDidChangeInterfaceLanguage,
-    afterUpdate({ params }) {
-      if (params.data.preferedLanguage) {
-        sendDidChangeInterfaceLanguage();
-      }
-    }
-  });
-};
-const syncAuthSettings = async () => {
-  const adminStore = await strapi.store({ type: "core", name: "admin" });
-  const adminAuthSettings = await adminStore.get({ key: "auth" });
-  const newAuthSettings = fp.merge(defaultAdminAuthSettings, adminAuthSettings);
-  const roleExists = await getService$1("role").exists({
-    id: newAuthSettings.providers.defaultRole
-  });
-  if (!roleExists) {
-    newAuthSettings.providers.defaultRole = null;
-  }
-  await adminStore.set({ key: "auth", value: newAuthSettings });
-};
-const syncAPITokensPermissions = async () => {
-  const validPermissions = strapi.contentAPI.permissions.providers.action.keys();
-  const permissionsInDB = await utils$1.async.pipe(
-    strapi.db.query("admin::api-token-permission").findMany,
-    fp.map("action")
-  )();
-  const unknownPermissions = fp.uniq(fp.difference(permissionsInDB, validPermissions));
-  if (unknownPermissions.length > 0) {
-    await strapi.db.query("admin::api-token-permission").deleteMany({ where: { action: { $in: unknownPermissions } } });
-  }
-};
-const executeCEBootstrap = async ({ strapi: strapi2 }) => {
-  await registerAdminConditions();
-  await registerPermissionActions();
-  registerModelHooks();
-  const permissionService = getService$1("permission");
-  const userService = getService$1("user");
-  const roleService = getService$1("role");
-  const apiTokenService = getService$1("api-token");
-  const transferService = getService$1("transfer");
-  const tokenService = getService$1("token");
-  await roleService.createRolesIfNoneExist();
-  await roleService.resetSuperAdminPermissions();
-  await roleService.displayWarningIfNoSuperAdmin();
-  await permissionService.cleanPermissionsInDatabase();
-  await userService.displayWarningIfUsersDontHaveRole();
-  await syncAuthSettings();
-  await syncAPITokensPermissions();
-  await getService$1("metrics").sendUpdateProjectInformation(strapi2);
-  getService$1("metrics").startCron(strapi2);
-  apiTokenService.checkSaltIsDefined();
-  transferService.token.checkSaltIsDefined();
-  tokenService.checkSecretIsDefined();
-};
-const getService = (name2, { strapi: strapi2 } = { strapi: global.strapi }) => {
-  return strapi2.service(`admin::${name2}`);
-};
-const actions = {
-  sso: [
-    {
-      uid: "provider-login.read",
-      displayName: "Read",
-      pluginName: "admin",
-      section: "settings",
-      category: "single sign on",
-      subCategory: "options"
-    },
-    {
-      uid: "provider-login.update",
-      displayName: "Update",
-      pluginName: "admin",
-      section: "settings",
-      category: "single sign on",
-      subCategory: "options"
-    }
-  ],
-  auditLogs: [
-    {
-      uid: "audit-logs.read",
-      displayName: "Read",
-      pluginName: "admin",
-      section: "settings",
-      category: "audit logs",
-      subCategory: "options"
-    }
-  ]
-};
-const transformTableName = (table) => {
-  if (typeof table === "string") {
-    return { name: table };
-  }
-  return table;
-};
-async function findTables({ strapi: strapi2 }, regex) {
-  const tables = await strapi2.db.dialect.schemaInspector.getTables();
-  return tables.filter((tableName) => regex.test(tableName));
-}
-async function addPersistTables({ strapi: strapi2 }, tableNames) {
-  const persistedTables = await getPersistedTables({ strapi: strapi2 });
-  const tables = tableNames.map(transformTableName);
-  const notPersistedTableNames = fp.differenceWith(fp.isEqual, tables, persistedTables);
-  const tablesToPersist = fp.differenceWith(
-    (t1, t2) => t1.name === t2.name,
-    persistedTables,
-    notPersistedTableNames
-  );
-  if (!notPersistedTableNames.length) {
-    return;
-  }
-  tablesToPersist.push(...notPersistedTableNames);
-  await strapi2.store.set({
-    type: "core",
-    key: "persisted_tables",
-    value: tablesToPersist
-  });
-}
-async function getPersistedTables({ strapi: strapi2 }) {
-  const persistedTables = await strapi2.store.get({
-    type: "core",
-    key: "persisted_tables"
-  });
-  return (persistedTables || []).map(transformTableName);
-}
-const persistTablesWithPrefix = async (tableNamePrefix) => {
-  const tableNameRegex = new RegExp(`^${tableNamePrefix}.*`);
-  const tableNames = await findTables({ strapi }, tableNameRegex);
-  await addPersistTables({ strapi }, tableNames);
-};
-const bootstrap = async (args) => {
-  const { actionProvider } = getService("permission");
-  if (strapi.ee.features.isEnabled("sso")) {
-    await actionProvider.registerMany(actions.sso);
-  }
-  if (strapi.ee.features.isEnabled("audit-logs")) {
-    await persistTablesWithPrefix("strapi_audit_logs");
-    await actionProvider.registerMany(actions.auditLogs);
-  }
-  await getService("seat-enforcement").seatEnforcementWorkflow();
-  await executeCEBootstrap(args);
-};
-const executeCEDestroy = async () => {
-  const { conditionProvider, actionProvider } = getService$1("permission");
-  await conditionProvider.clear();
-  await actionProvider.clear();
-};
-const destroy = async ({ strapi: strapi2 }) => {
-  await executeCEDestroy();
-};
-const adminContentTypes = {};
-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(
-    {
-      usernameField: "email",
-      passwordField: "password",
-      session: false
-    },
-    (email2, password2, done) => {
-      return getService$1("auth").checkCredentials({ email: fp.toLower(email2), password: password2 }).then(async ([error, user2, message]) => {
-        if (middleware) {
-          return middleware([error, user2, message], done);
-        }
-        return done(error, user2, message);
-      }).catch((error) => done(error));
-    }
-  );
-};
-const authEventsMapper = {
-  onConnectionSuccess: "admin.auth.success",
-  onConnectionError: "admin.auth.error"
-};
-const valueIsFunctionType = ([, value]) => fp.isFunction(value);
-const keyIsValidEventName = ([key]) => {
-  return Object.keys(strapi.service("admin::passport").authEventsMapper).includes(key);
-};
-const getPassportStrategies$1 = () => [createLocalStrategy(strapi)];
-const registerAuthEvents = () => {
-  const { events = {} } = strapi.config.get("admin.auth", {});
-  const { authEventsMapper: authEventsMapper2 } = strapi.service("admin::passport");
-  const eventList = Object.entries(events).filter(keyIsValidEventName).filter(valueIsFunctionType);
-  for (const [eventName, handler] of eventList) {
-    strapi.eventHub.on(authEventsMapper2[eventName], handler);
-  }
-};
-const init = () => {
-  strapi.service("admin::passport").getPassportStrategies().forEach((strategy) => passport__default.default.use(strategy));
-  registerAuthEvents();
-  return passport__default.default.initialize();
-};
-const passport$1 = { init, getPassportStrategies: getPassportStrategies$1, authEventsMapper };
-const createProviderRegistry = () => {
-  const registry = /* @__PURE__ */ new Map();
-  Object.assign(registry, {
-    register(provider) {
-      if (strapi.isLoaded) {
-        throw new Error(`You can't register new provider after the bootstrap`);
-      }
-      this.set(provider.uid, provider);
-    },
-    registerMany(providers) {
-      providers.forEach((provider) => {
-        this.register(provider);
-      });
-    },
-    getAll() {
-      return Array.from(this.values());
-    }
-  });
-  return registry;
-};
-const providerRegistry = createProviderRegistry();
-const errorMessage = "SSO is disabled. Its functionnalities cannot be accessed.";
-const getStrategyCallbackURL = (providerName) => {
-  if (!strapi.ee.features.isEnabled("sso")) {
-    throw new Error(errorMessage);
-  }
-  return `/admin/connect/${providerName}`;
-};
-const syncProviderRegistryWithConfig = () => {
-  if (!strapi.ee.features.isEnabled("sso")) {
-    throw new Error(errorMessage);
-  }
-  const { providers = [] } = strapi.config.get("admin.auth", {});
-  providerRegistry.registerMany(providers);
-};
-const SSOAuthEventsMapper = {
-  onSSOAutoRegistration: "admin.auth.autoRegistration"
-};
-const sso$1 = {
-  providerRegistry,
-  getStrategyCallbackURL,
-  syncProviderRegistryWithConfig,
-  authEventsMapper: { ...passport$1.authEventsMapper, ...SSOAuthEventsMapper }
-};
-const { UnauthorizedError } = utils$1.errors;
-const localStrategyMiddleware = async ([error, user2, message], done) => {
-  if (user2 && !error && await isSsoLocked(user2)) {
-    return done(
-      new UnauthorizedError("Login not allowed, please contact your administrator", {
-        code: "LOGIN_NOT_ALLOWED"
-      }),
-      user2,
-      message
-    );
-  }
-  return done(error, user2, message);
-};
-const getPassportStrategies = () => {
-  if (!strapi.ee.features.isEnabled("sso")) {
-    return [createLocalStrategy(strapi)];
-  }
-  const localStrategy = createLocalStrategy(strapi, localStrategyMiddleware);
-  if (!strapi.isLoaded) {
-    sso$1.syncProviderRegistryWithConfig();
-  }
-  const providers = sso$1.providerRegistry.getAll();
-  const strategies = providers.map((provider) => provider.createStrategy(strapi));
-  return [localStrategy, ...strategies];
-};
-const passport = {
-  getPassportStrategies,
-  ...sso$1
-};
-const { ApplicationError: ApplicationError$1 } = utils$1.errors;
-const ssoCheckRolesIdForDeletion = async (ids) => {
-  const adminStore = await strapi.store({ type: "core", name: "admin" });
-  const {
-    providers: { defaultRole }
-  } = await adminStore.get({ key: "auth" });
-  for (const roleId of ids) {
-    if (defaultRole && fp.toString(defaultRole) === fp.toString(roleId)) {
-      throw new ApplicationError$1(
-        "This role is used as the default SSO role. Make sure to change this configuration before deleting the role"
-      );
-    }
-  }
-};
-const role$1 = {
-  ssoCheckRolesIdForDeletion
-};
-const { SUPER_ADMIN_CODE: SUPER_ADMIN_CODE$2 } = constants;
-const hasSuperAdminRole = (user2) => {
-  return user2.roles.filter((role2) => role2.code === SUPER_ADMIN_CODE$2).length > 0;
-};
-const { ValidationError: ValidationError$1 } = utils$1.errors;
-const { SUPER_ADMIN_CODE: SUPER_ADMIN_CODE$1 } = constants;
-const updateEEDisabledUsersList = async (id, input) => {
-  const disabledUsers = await getService("seat-enforcement").getDisabledUserList();
-  if (!disabledUsers) {
-    return;
-  }
-  const user2 = disabledUsers.find((user22) => user22.id === Number(id));
-  if (!user2) {
-    return;
-  }
-  if (user2.isActive !== input.isActive) {
-    const newDisabledUsersList = disabledUsers.filter((user22) => user22.id !== Number(id));
-    await strapi.store.set({
-      type: "ee",
-      key: "disabled_users",
-      value: newDisabledUsersList
-    });
-  }
-};
-const castNumberArray = fp.pipe(fp.castArray, fp.map(fp.toNumber));
-const removeFromEEDisabledUsersList = async (ids) => {
-  let idsToCheck;
-  if (typeof ids === "object") {
-    idsToCheck = castNumberArray(ids);
-  } else {
-    idsToCheck = [Number(ids)];
-  }
-  const disabledUsers = await getService("seat-enforcement").getDisabledUserList();
-  if (!disabledUsers) {
-    return;
-  }
-  const newDisabledUsersList = disabledUsers.filter((user2) => !idsToCheck.includes(user2.id));
-  await strapi.store.set({
-    type: "ee",
-    key: "disabled_users",
-    value: newDisabledUsersList
-  });
-};
-const updateById = async (id, attributes) => {
-  if (___default.default.has(attributes, "roles")) {
-    const lastAdminUser = await isLastSuperAdminUser(id);
-    const superAdminRole = await getService("role").getSuperAdminWithUsersCount();
-    const willRemoveSuperAdminRole = !utils$1.arrays.includesString(attributes.roles, superAdminRole.id);
-    if (lastAdminUser && willRemoveSuperAdminRole) {
-      throw new ValidationError$1("You must have at least one user with super admin role.");
-    }
-  }
-  if (attributes.isActive === false) {
-    const lastAdminUser = await isLastSuperAdminUser(id);
-    if (lastAdminUser) {
-      throw new ValidationError$1("You must have at least one user with super admin role.");
-    }
-  }
-  if (___default.default.has(attributes, "password")) {
-    const hashedPassword = await getService("auth").hashPassword(attributes.password);
-    const updatedUser2 = await strapi.db.query("admin::user").update({
-      where: { id },
-      data: {
-        ...attributes,
-        password: hashedPassword
-      },
-      populate: ["roles"]
-    });
-    strapi.eventHub.emit("user.update", { user: sanitizeUser(updatedUser2) });
-    return updatedUser2;
-  }
-  const updatedUser = await strapi.db.query("admin::user").update({
-    where: { id },
-    data: attributes,
-    populate: ["roles"]
-  });
-  await updateEEDisabledUsersList(id, attributes);
-  if (updatedUser) {
-    strapi.eventHub.emit("user.update", { user: sanitizeUser(updatedUser) });
-  }
-  return updatedUser;
-};
-const deleteById = async (id) => {
-  const userToDelete = await strapi.db.query("admin::user").findOne({
-    where: { id },
-    populate: ["roles"]
-  });
-  if (!userToDelete) {
-    return null;
-  }
-  if (userToDelete) {
-    if (userToDelete.roles.some((r) => r.code === SUPER_ADMIN_CODE$1)) {
-      const superAdminRole = await getService("role").getSuperAdminWithUsersCount();
-      if (superAdminRole.usersCount === 1) {
-        throw new ValidationError$1("You must have at least one user with super admin role.");
-      }
-    }
-  }
-  const deletedUser = await strapi.db.query("admin::user").delete({ where: { id }, populate: ["roles"] });
-  await removeFromEEDisabledUsersList(id);
-  strapi.eventHub.emit("user.delete", { user: sanitizeUser(deletedUser) });
-  return deletedUser;
-};
-const deleteByIds = async (ids) => {
-  const superAdminRole = await getService("role").getSuperAdminWithUsersCount();
-  const nbOfSuperAdminToDelete = await strapi.db.query("admin::user").count({
-    where: {
-      id: ids,
-      roles: { id: superAdminRole.id }
-    }
-  });
-  if (superAdminRole.usersCount === nbOfSuperAdminToDelete) {
-    throw new ValidationError$1("You must have at least one user with super admin role.");
-  }
-  const deletedUsers = [];
-  for (const id of ids) {
-    const deletedUser = await strapi.db.query("admin::user").delete({
-      where: { id },
-      populate: ["roles"]
-    });
-    deletedUsers.push(deletedUser);
-  }
-  await removeFromEEDisabledUsersList(ids);
-  strapi.eventHub.emit("user.delete", {
-    users: deletedUsers.map((deletedUser) => sanitizeUser(deletedUser))
-  });
-  return deletedUsers;
-};
-const sanitizeUserRoles = (role2) => ___default.default.pick(role2, ["id", "name", "description", "code"]);
-const isLastSuperAdminUser = async (userId) => {
-  const user2 = await findOne(userId);
-  const superAdminRole = await getService("role").getSuperAdminWithUsersCount();
-  return superAdminRole.usersCount === 1 && hasSuperAdminRole(user2);
-};
-const sanitizeUser = (user2) => {
-  return {
-    ...___default.default.omit(user2, ["password", "resetPasswordToken", "registrationToken", "roles"]),
-    roles: user2.roles && user2.roles.map(sanitizeUserRoles)
-  };
-};
-const findOne = async (id, populate = ["roles"]) => {
-  return strapi.db.query("admin::user").findOne({ where: { id }, populate });
-};
-const getCurrentActiveUserCount = async () => {
-  return strapi.db.query("admin::user").count({ where: { isActive: true } });
-};
-const user$1 = {
-  updateEEDisabledUsersList,
-  removeFromEEDisabledUsersList,
-  getCurrentActiveUserCount,
-  deleteByIds,
-  deleteById,
-  updateById
-};
-const getSSOProvidersList = async () => {
-  const { providerRegistry: providerRegistry2 } = strapi.service("admin::passport");
-  return providerRegistry2.getAll().map(({ uid }) => uid);
-};
-const sendUpdateProjectInformation = async (strapi2) => {
-  let groupProperties = {};
-  const numberOfActiveAdminUsers = await getService("user").count({ isActive: true });
-  const numberOfAdminUsers = await getService("user").count();
-  if (strapi2.ee.features.isEnabled("sso")) {
-    const SSOProviders = await getSSOProvidersList();
-    groupProperties = fp.assign(groupProperties, {
-      SSOProviders,
-      isSSOConfigured: SSOProviders.length !== 0
-    });
-  }
-  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({
-      filters: { releasedAt: { $notNull: true } }
-    });
-    groupProperties = fp.assign(groupProperties, {
-      numberOfContentReleases,
-      numberOfPublishedContentReleases
-    });
-  }
-  groupProperties = fp.assign(groupProperties, { numberOfActiveAdminUsers, numberOfAdminUsers });
-  strapi2.telemetry.send("didUpdateProjectInformation", {
-    groupProperties
-  });
-};
-const startCron = (strapi2) => {
-  strapi2.cron.add({
-    "0 0 0 * * *": () => sendUpdateProjectInformation(strapi2)
-  });
-};
-const metrics = { startCron, getSSOProvidersList, sendUpdateProjectInformation };
-const { SUPER_ADMIN_CODE } = constants;
-const getDisabledUserList = async () => {
-  return strapi.store.get({ type: "ee", key: "disabled_users" });
-};
-const enableMaximumUserCount = async (numberOfUsersToEnable) => {
-  const disabledUsers = await getDisabledUserList();
-  const orderedDisabledUsers = fp.reverse(disabledUsers);
-  const usersToEnable = fp.take(numberOfUsersToEnable, orderedDisabledUsers);
-  await strapi.db.query("admin::user").updateMany({
-    where: { id: fp.map(fp.prop("id"), usersToEnable) },
-    data: { isActive: true }
-  });
-  const remainingDisabledUsers = fp.drop(numberOfUsersToEnable, orderedDisabledUsers);
-  await strapi.store.set({
-    type: "ee",
-    key: "disabled_users",
-    value: remainingDisabledUsers
-  });
-};
-const disableUsersAboveLicenseLimit = async (numberOfUsersToDisable) => {
-  const currentlyDisabledUsers = await getDisabledUserList() ?? [];
-  const usersToDisable = [];
-  const nonSuperAdminUsersToDisable = await strapi.db.query("admin::user").findMany({
-    where: {
-      isActive: true,
-      roles: {
-        code: { $ne: SUPER_ADMIN_CODE }
-      }
-    },
-    orderBy: { createdAt: "DESC" },
-    limit: numberOfUsersToDisable
-  });
-  usersToDisable.push(...nonSuperAdminUsersToDisable);
-  if (nonSuperAdminUsersToDisable.length < numberOfUsersToDisable) {
-    const superAdminUsersToDisable = await strapi.db.query("admin::user").findMany({
-      where: {
-        isActive: true,
-        roles: { code: SUPER_ADMIN_CODE }
-      },
-      orderBy: { createdAt: "DESC" },
-      limit: numberOfUsersToDisable - nonSuperAdminUsersToDisable.length
-    });
-    usersToDisable.push(...superAdminUsersToDisable);
-  }
-  await strapi.db.query("admin::user").updateMany({
-    where: { id: fp.map(fp.prop("id"), usersToDisable) },
-    data: { isActive: false }
-  });
-  await strapi.store.set({
-    type: "ee",
-    key: "disabled_users",
-    value: currentlyDisabledUsers.concat(fp.map(fp.pick(["id", "isActive"]), usersToDisable))
-  });
-};
-const syncDisabledUserRecords = async () => {
-  const disabledUsers = await strapi.store.get({ type: "ee", key: "disabled_users" });
-  if (!disabledUsers) {
-    return;
-  }
-  await strapi.db.query("admin::user").updateMany({
-    where: { id: fp.map(fp.prop("id"), disabledUsers) },
-    data: { isActive: false }
-  });
-};
-const seatEnforcementWorkflow = async () => {
-  const adminSeats = strapi.ee.seats;
-  if (fp.isNil(adminSeats)) {
-    return;
-  }
-  await syncDisabledUserRecords();
-  const currentActiveUserCount = await getService("user").getCurrentActiveUserCount();
-  const adminSeatsLeft = adminSeats - currentActiveUserCount;
-  if (adminSeatsLeft > 0) {
-    await enableMaximumUserCount(adminSeatsLeft);
-  } else if (adminSeatsLeft < 0) {
-    await disableUsersAboveLicenseLimit(-adminSeatsLeft);
-  }
-};
-const seatEnforcement = {
-  seatEnforcementWorkflow,
-  getDisabledUserList
-};
-const services = {
-  auth,
-  passport,
-  role: role$1,
-  user: user$1,
-  metrics,
-  "seat-enforcement": seatEnforcement
-};
-const providerOptionsUpdateSchema = utils$1.yup.object().shape({
-  autoRegister: utils$1.yup.boolean().required(),
-  defaultRole: utils$1.yup.strapiID().when("autoRegister", (value, initSchema) => {
-    return value ? initSchema.required() : initSchema.nullable();
-  }).test("is-valid-role", "You must submit a valid default role", (roleId) => {
-    if (roleId === null) {
-      return true;
-    }
-    return strapi.service("admin::role").exists({ id: roleId });
-  }),
-  ssoLockedRoles: utils$1.yup.array().nullable().of(
-    utils$1.yup.strapiID().test(
-      "is-valid-role",
-      "You must submit a valid role for the SSO Locked roles",
-      (roleId) => {
-        return strapi.service("admin::role").exists({ id: roleId });
-      }
-    )
-  )
-});
-const validateProviderOptionsUpdate = utils$1.validateYupSchema(providerOptionsUpdateSchema);
-const PROVIDER_REDIRECT_BASE = "/auth/login";
-const PROVIDER_REDIRECT_SUCCESS = `${PROVIDER_REDIRECT_BASE}/success`;
-const PROVIDER_REDIRECT_ERROR = `${PROVIDER_REDIRECT_BASE}/error`;
-const PROVIDER_URLS_MAP = {
-  success: PROVIDER_REDIRECT_SUCCESS,
-  error: PROVIDER_REDIRECT_ERROR
-};
-const getAdminStore = async () => strapi.store({ type: "core", name: "admin" });
-const getPrefixedRedirectUrls = () => {
-  const { url: adminUrl } = strapi.config.get("admin");
-  const prefixUrl = (url) => `${adminUrl || "/admin"}${url}`;
-  return fp.mapValues(prefixUrl, PROVIDER_URLS_MAP);
-};
-const utils = {
-  getAdminStore,
-  getPrefixedRedirectUrls
-};
-const defaultConnectionError = () => new Error("Invalid connection payload");
-const authenticate = async (ctx, next) => {
-  const {
-    params: { provider }
-  } = ctx;
-  const redirectUrls = utils.getPrefixedRedirectUrls();
-  return passport__default.default.authenticate(provider, null, async (error, profile) => {
-    if (error || !profile || !profile.email) {
-      if (error) {
-        strapi.log.error(error);
-      }
-      strapi.eventHub.emit("admin.auth.error", {
-        error: error || defaultConnectionError(),
-        provider
-      });
-      return ctx.redirect(redirectUrls.error);
-    }
-    const user2 = await getService("user").findOneByEmail(profile.email);
-    const scenario = user2 ? existingUserScenario : nonExistingUserScenario;
-    return scenario(ctx, next)(user2 || profile, provider);
-  })(ctx, next);
-};
-const existingUserScenario = (ctx, next) => async (user2, provider) => {
-  const redirectUrls = utils.getPrefixedRedirectUrls();
-  if (!user2.isActive) {
-    strapi.eventHub.emit("admin.auth.error", {
-      error: new Error(`Deactivated user tried to login (${user2.id})`),
-      provider
-    });
-    return ctx.redirect(redirectUrls.error);
-  }
-  ctx.state.user = user2;
-  return next();
-};
-const nonExistingUserScenario = (ctx, next) => async (profile, provider) => {
-  const { email: email2, firstname: firstname2, lastname: lastname2, username: username2 } = profile;
-  const redirectUrls = utils.getPrefixedRedirectUrls();
-  const adminStore = await utils.getAdminStore();
-  const { providers } = await adminStore.get({ key: "auth" });
-  const isMissingRegisterFields = !username2 && (!firstname2 || !lastname2);
-  if (!providers.autoRegister || !providers.defaultRole || isMissingRegisterFields) {
-    strapi.eventHub.emit("admin.auth.error", { error: defaultConnectionError(), provider });
-    return ctx.redirect(redirectUrls.error);
-  }
-  const defaultRole = await getService("role").findOne({ id: providers.defaultRole });
-  if (!defaultRole) {
-    strapi.eventHub.emit("admin.auth.error", { error: defaultConnectionError(), provider });
-    return ctx.redirect(redirectUrls.error);
-  }
-  ctx.state.user = await getService("user").create({
-    email: email2,
-    username: username2,
-    firstname: firstname2,
-    lastname: lastname2,
-    roles: [defaultRole.id],
-    isActive: true,
-    registrationToken: null
-  });
-  strapi.eventHub.emit("admin.auth.autoRegistration", {
-    user: ctx.state.user,
-    provider
-  });
-  return next();
-};
-const redirectWithAuth = (ctx) => {
-  const {
-    params: { provider }
-  } = ctx;
-  const redirectUrls = utils.getPrefixedRedirectUrls();
-  const domain = strapi.config.get("admin.auth.domain");
-  const { user: user2 } = ctx.state;
-  const jwt = getService("token").createJwtToken(user2);
-  const isProduction = strapi.config.get("environment") === "production";
-  const cookiesOptions = { httpOnly: false, secure: isProduction, overwrite: true, domain };
-  const sanitizedUser = getService("user").sanitizeUser(user2);
-  strapi.eventHub.emit("admin.auth.success", { user: sanitizedUser, provider });
-  ctx.cookies.set("jwtToken", jwt, cookiesOptions);
-  ctx.redirect(redirectUrls.success);
-};
-const middlewares = {
-  authenticate,
-  redirectWithAuth
-};
-const toProviderDTO = fp.pick(["uid", "displayName", "icon"]);
-const toProviderLoginOptionsDTO = fp.pick(["autoRegister", "defaultRole", "ssoLockedRoles"]);
-const { ValidationError } = utils$1.errors;
-const providerAuthenticationFlow = compose__default.default([
-  middlewares.authenticate,
-  middlewares.redirectWithAuth
-]);
-const authentication = {
-  async getProviders(ctx) {
-    const { providerRegistry: providerRegistry2 } = strapi.service("admin::passport");
-    ctx.body = providerRegistry2.getAll().map(toProviderDTO);
-  },
-  async getProviderLoginOptions(ctx) {
-    const adminStore = await utils.getAdminStore();
-    const { providers: providersOptions } = await adminStore.get({ key: "auth" });
-    ctx.body = {
-      data: toProviderLoginOptionsDTO(providersOptions)
-    };
-  },
-  async updateProviderLoginOptions(ctx) {
-    const {
-      request: { body }
-    } = ctx;
-    await validateProviderOptionsUpdate(body);
-    const adminStore = await utils.getAdminStore();
-    const currentAuthOptions = await adminStore.get({ key: "auth" });
-    const newAuthOptions = { ...currentAuthOptions, providers: body };
-    await adminStore.set({ key: "auth", value: newAuthOptions });
-    strapi.telemetry.send("didUpdateSSOSettings");
-    ctx.body = {
-      data: toProviderLoginOptionsDTO(newAuthOptions.providers)
-    };
-  },
-  providerLogin(ctx, next) {
-    const {
-      params: { provider: providerName }
-    } = ctx;
-    const { providerRegistry: providerRegistry2 } = strapi.service("admin::passport");
-    if (!providerRegistry2.has(providerName)) {
-      throw new ValidationError(`Invalid provider supplied: ${providerName}`);
-    }
-    return providerAuthenticationFlow(ctx, next);
-  }
-};
-const roleCreateSchema = utils$1.yup.object().shape({
-  name: utils$1.yup.string().min(1).required(),
-  description: utils$1.yup.string().nullable()
-}).noUnknown();
-const rolesDeleteSchema = utils$1.yup.object().shape({
-  ids: utils$1.yup.array().of(utils$1.yup.strapiID()).min(1).required().test(
-    "roles-deletion-checks",
-    "Roles deletion checks have failed",
-    async function rolesDeletionChecks(ids) {
-      try {
-        await strapi.service("admin::role").checkRolesIdForDeletion(ids);
-        if (strapi.ee.features.isEnabled("sso")) {
-          await strapi.service("admin::role").ssoCheckRolesIdForDeletion(ids);
-        }
-      } catch (e) {
-        return this.createError({ path: "ids", message: e.message });
-      }
-      return true;
-    }
-  )
-}).noUnknown();
-const roleDeleteSchema = utils$1.yup.strapiID().required().test(
-  "no-admin-single-delete",
-  "Role deletion checks have failed",
-  async function noAdminSingleDelete(id) {
-    try {
-      await strapi.service("admin::role").checkRolesIdForDeletion([id]);
-      if (strapi.ee.features.isEnabled("sso")) {
-        await strapi.service("admin::role").ssoCheckRolesIdForDeletion([id]);
-      }
-    } catch (e) {
-      return this.createError({ path: "id", message: e.message });
-    }
-    return true;
-  }
-);
-const validateRoleCreateInput = utils$1.validateYupSchema(roleCreateSchema);
-const validateRolesDeleteInput = utils$1.validateYupSchema(rolesDeleteSchema);
-const validateRoleDeleteInput = utils$1.validateYupSchema(roleDeleteSchema);
-const role = {
-  /**
-   * Create a new role
-   * @param {KoaContext} ctx - koa context
-   */
-  async create(ctx) {
-    await validateRoleCreateInput(ctx.request.body);
-    const roleService = getService("role");
-    const role2 = await roleService.create(ctx.request.body);
-    const sanitizedRole = roleService.sanitizeRole(role2);
-    ctx.created({ data: sanitizedRole });
-  },
-  /**
-   * Delete a role
-   * @param {KoaContext} ctx - koa context
-   */
-  async deleteOne(ctx) {
-    const { id } = ctx.params;
-    await validateRoleDeleteInput(id);
-    const roleService = getService("role");
-    const roles2 = await roleService.deleteByIds([id]);
-    const sanitizedRole = roles2.map((role2) => roleService.sanitizeRole(role2))[0] || null;
-    return ctx.deleted({
-      data: sanitizedRole
-    });
-  },
-  /**
-   * delete several roles
-   * @param {KoaContext} ctx - koa context
-   */
-  async deleteMany(ctx) {
-    const { body } = ctx.request;
-    await validateRolesDeleteInput(body);
-    const roleService = getService("role");
-    const roles2 = await roleService.deleteByIds(body.ids);
-    const sanitizedRoles = roles2.map(roleService.sanitizeRole);
-    return ctx.deleted({
-      data: sanitizedRoles
-    });
-  }
-};
-const getDefaultActionAttributes = () => ({
-  options: {
-    applyToProperties: null
-  }
-});
-const actionFields = [
-  "section",
-  "displayName",
-  "category",
-  "subCategory",
-  "pluginName",
-  "subjects",
-  "options",
-  "actionId",
-  "aliases"
-];
-const sanitizeActionAttributes = fp.pick(actionFields);
-const computeActionId = (attributes) => {
-  const { pluginName, uid } = attributes;
-  if (!pluginName) {
-    return `api::${uid}`;
-  }
-  if (pluginName === "admin") {
-    return `admin::${uid}`;
-  }
-  return `plugin::${pluginName}.${uid}`;
-};
-const assignActionId = (attrs) => fp.set("actionId", computeActionId(attrs), attrs);
-const assignOrOmitSubCategory = (action) => {
-  const shouldHaveSubCategory = ["settings", "plugins"].includes(action.section);
-  return shouldHaveSubCategory ? fp.set("subCategory", action.subCategory || "general", action) : fp.omit("subCategory", action);
-};
-const appliesToProperty = fp.curry((property, action) => {
-  return fp.pipe(fp.prop("options.applyToProperties"), fp.includes(property))(action);
-});
-const appliesToSubject = fp.curry((subject, action) => {
-  return fp.isArray(action.subjects) && fp.includes(subject, action.subjects);
-});
-const create = fp.pipe(
-  // Create and assign an action identifier to the action
-  // (need to be done before the sanitizeActionAttributes since we need the uid here)
-  assignActionId,
-  // Add or remove the sub category field based on the pluginName attribute
-  assignOrOmitSubCategory,
-  // Remove unwanted attributes from the payload
-  sanitizeActionAttributes,
-  // Complete the action creation by adding default values for some attributes
-  fp.merge(getDefaultActionAttributes())
-);
-const actionDomain = {
-  actionFields,
-  appliesToProperty,
-  appliesToSubject,
-  assignActionId,
-  assignOrOmitSubCategory,
-  create,
-  computeActionId,
-  getDefaultActionAttributes,
-  sanitizeActionAttributes
-};
-const checkFieldsAreCorrectlyNested = (fields) => {
-  if (___default.default.isNil(fields)) {
-    return true;
-  }
-  if (!Array.isArray(fields)) {
-    return false;
-  }
-  let failed = false;
-  for (let indexA = 0; indexA < fields.length; indexA += 1) {
-    failed = fields.slice(indexA + 1).some(
-      (fieldB) => fieldB.startsWith(`${fields[indexA]}.`) || fields[indexA].startsWith(`${fieldB}.`)
-    );
-    if (failed)
-      break;
-  }
-  return !failed;
-};
-const checkFieldsDontHaveDuplicates = (fields) => {
-  if (___default.default.isNil(fields)) {
-    return true;
-  }
-  if (!Array.isArray(fields)) {
-    return false;
-  }
-  return ___default.default.uniq(fields).length === fields.length;
-};
-const getActionFromProvider = (actionId) => {
-  return getService$1("permission").actionProvider.get(actionId);
-};
-const email = utils$1.yup.string().email().lowercase();
-const firstname = utils$1.yup.string().trim().min(1);
-const lastname = utils$1.yup.string();
-const username = utils$1.yup.string().min(1);
-const password = utils$1.yup.string().min(8).matches(/[a-z]/, "${path} must contain at least one lowercase character").matches(/[A-Z]/, "${path} must contain at least one uppercase character").matches(/\d/, "${path} must contain at least one number");
-const roles = utils$1.yup.array(utils$1.yup.strapiID()).min(1);
-const isAPluginName = utils$1.yup.string().test("is-a-plugin-name", "is not a plugin name", function(value) {
-  return [void 0, "admin", ...Object.keys(strapi.plugins)].includes(value) ? true : this.createError({ path: this.path, message: `${this.path} is not an existing plugin` });
-});
-const arrayOfConditionNames = utils$1.yup.array().of(utils$1.yup.string()).test("is-an-array-of-conditions", "is not a plugin name", function(value) {
-  const ids = strapi.service("admin::permission").conditionProvider.keys();
-  return ___default.default.isUndefined(value) || ___default.default.difference(value, ids).length === 0 ? true : this.createError({ path: this.path, message: `contains conditions that don't exist` });
-});
-const permissionsAreEquals = (a, b) => a.action === b.action && (a.subject === b.subject || ___default.default.isNil(a.subject) && ___default.default.isNil(b.subject));
-const checkNoDuplicatedPermissions = (permissions) => !Array.isArray(permissions) || permissions.every(
-  (permA, i) => permissions.slice(i + 1).every((permB) => !permissionsAreEquals(permA, permB))
-);
-const checkNilFields = (action) => function(fields) {
-  if (fp.isNil(action)) {
-    return true;
-  }
-  return actionDomain.appliesToProperty("fields", action) || fp.isNil(fields);
-};
-const fieldsPropertyValidation = (action) => utils$1.yup.array().of(utils$1.yup.string()).nullable().test(
-  "field-nested",
-  "Fields format are incorrect (bad nesting).",
-  checkFieldsAreCorrectlyNested
-).test(
-  "field-nested",
-  "Fields format are incorrect (duplicates).",
-  checkFieldsDontHaveDuplicates
-).test(
-  "fields-restriction",
-  "The permission at ${path} must have fields set to null or undefined",
-  // @ts-expect-error yup types
-  checkNilFields(action)
-);
-const permission = utils$1.yup.object().shape({
-  action: utils$1.yup.string().required().test("action-validity", "action is not an existing permission action", function(actionId) {
-    if (fp.isNil(actionId)) {
-      return true;
-    }
-    return !!getActionFromProvider(actionId);
-  }),
-  actionParameters: utils$1.yup.object().nullable(),
-  subject: utils$1.yup.string().nullable().test("subject-validity", "Invalid subject submitted", function(subject) {
-    const action = getActionFromProvider(this.options.parent.action);
-    if (!action) {
-      return true;
-    }
-    if (fp.isNil(action.subjects)) {
-      return fp.isNil(subject);
-    }
-    if (fp.isArray(action.subjects) && !fp.isNil(subject)) {
-      return action.subjects.includes(subject);
-    }
-    return false;
-  }),
-  properties: utils$1.yup.object().test("properties-structure", "Invalid property set at ${path}", function(properties) {
-    const action = getActionFromProvider(this.options.parent.action);
-    const hasNoProperties = fp.isEmpty(properties) || fp.isNil(properties);
-    if (!fp.has("options.applyToProperties", action)) {
-      return hasNoProperties;
-    }
-    if (hasNoProperties) {
-      return true;
-    }
-    const { applyToProperties } = action.options;
-    if (!fp.isArray(applyToProperties)) {
-      return false;
-    }
-    return Object.keys(properties).every((property) => applyToProperties.includes(property));
-  }).test(
-    "fields-property",
-    "Invalid fields property at ${path}",
-    async function(properties = {}) {
-      const action = getActionFromProvider(this.options.parent.action);
-      if (!action || !properties) {
-        return true;
-      }
-      if (!actionDomain.appliesToProperty("fields", action)) {
-        return true;
-      }
-      try {
-        await fieldsPropertyValidation(action).validate(properties.fields, {
-          strict: true,
-          abortEarly: false
-        });
-        return true;
-      } catch (e) {
-        throw this.createError({
-          message: e.message,
-          path: `${this.path}.fields`
-        });
-      }
-    }
-  ),
-  conditions: utils$1.yup.array().of(utils$1.yup.string())
-}).noUnknown();
-const updatePermissions = utils$1.yup.object().shape({
-  permissions: utils$1.yup.array().required().of(permission).test(
-    "duplicated-permissions",
-    "Some permissions are duplicated (same action and subject)",
-    checkNoDuplicatedPermissions
-  )
-}).required().noUnknown();
-const validators = {
-  email,
-  firstname,
-  lastname,
-  username,
-  password,
-  roles,
-  isAPluginName,
-  arrayOfConditionNames,
-  permission,
-  updatePermissions
-};
-const userCreationSchema = utils$1.yup.object().shape({
-  email: validators.email.required(),
-  firstname: validators.firstname.required(),
-  lastname: validators.lastname,
-  roles: validators.roles.min(1),
-  preferedLanguage: utils$1.yup.string().nullable()
-}).noUnknown();
-const profileUpdateSchema = utils$1.yup.object().shape({
-  email: validators.email.notNull(),
-  firstname: validators.firstname.notNull(),
-  lastname: validators.lastname.nullable(),
-  username: validators.username.nullable(),
-  password: validators.password.notNull(),
-  currentPassword: utils$1.yup.string().when(
-    "password",
-    (password2, schema) => !fp.isUndefined(password2) ? schema.required() : schema
-  ).notNull(),
-  preferedLanguage: utils$1.yup.string().nullable()
-}).noUnknown();
-const userUpdateSchema = utils$1.yup.object().shape({
-  email: validators.email.notNull(),
-  firstname: validators.firstname.notNull(),
-  lastname: validators.lastname.nullable(),
-  username: validators.username.nullable(),
-  password: validators.password.notNull(),
-  isActive: utils$1.yup.bool().notNull(),
-  roles: validators.roles.min(1).notNull()
-}).noUnknown();
-const usersDeleteSchema = utils$1.yup.object().shape({
-  ids: utils$1.yup.array().of(utils$1.yup.strapiID()).min(1).required()
-}).noUnknown();
-utils$1.validateYupSchema(userCreationSchema);
-utils$1.validateYupSchema(profileUpdateSchema);
-const validateUserUpdateInput = utils$1.validateYupSchema(userUpdateSchema);
-utils$1.validateYupSchema(usersDeleteSchema);
-const schemas = {
-  userCreationSchema,
-  usersDeleteSchema,
-  userUpdateSchema
-};
-const ssoUserCreationInputExtension = utils$1.yup.object().shape({
-  useSSORegistration: utils$1.yup.boolean()
-}).noUnknown();
-const validateUserCreationInput = (data) => {
-  let schema = schemas.userCreationSchema;
-  if (strapi.ee.features.isEnabled("sso")) {
-    schema = schema.concat(ssoUserCreationInputExtension);
-  }
-  return utils$1.validateYupSchema(schema)(data);
-};
-const { ApplicationError, ForbiddenError } = utils$1.errors;
-const pickUserCreationAttributes = fp.pick(["firstname", "lastname", "email", "roles"]);
-const hasAdminSeatsAvaialble = async () => {
-  if (!strapi.EE) {
-    return true;
-  }
-  const permittedSeats = strapi.ee.seats;
-  if (fp.isNil(permittedSeats)) {
-    return true;
-  }
-  const userCount = await strapi.service("admin::user").getCurrentActiveUserCount();
-  if (userCount < permittedSeats) {
-    return true;
-  }
-};
-const user = {
-  async create(ctx) {
-    if (!await hasAdminSeatsAvaialble()) {
-      throw new ForbiddenError("License seat limit reached. You cannot create a new user");
-    }
-    const { body } = ctx.request;
-    const cleanData = { ...body, email: ___default.default.get(body, `email`, ``).toLowerCase() };
-    await validateUserCreationInput(cleanData);
-    const attributes = pickUserCreationAttributes(cleanData);
-    const { useSSORegistration } = cleanData;
-    const userAlreadyExists = await getService("user").exists({ email: attributes.email });
-    if (userAlreadyExists) {
-      throw new ApplicationError("Email already taken");
-    }
-    if (useSSORegistration) {
-      Object.assign(attributes, { registrationToken: null, isActive: true });
-    }
-    const createdUser = await getService("user").create(attributes);
-    const userInfo = getService("user").sanitizeUser(createdUser);
-    Object.assign(userInfo, { registrationToken: createdUser.registrationToken });
-    ctx.created({ data: userInfo });
-  },
-  async update(ctx) {
-    const { id } = ctx.params;
-    const { body: input } = ctx.request;
-    await validateUserUpdateInput(input);
-    if (___default.default.has(input, "email")) {
-      const uniqueEmailCheck = await getService("user").exists({
-        id: { $ne: id },
-        email: input.email
-      });
-      if (uniqueEmailCheck) {
-        throw new ApplicationError("A user with this email address already exists");
-      }
-    }
-    const user2 = await getService("user").findOne(id, null);
-    if (!await hasAdminSeatsAvaialble() && !user2.isActive && input.isActive) {
-      throw new ForbiddenError("License seat limit reached. You cannot active this user");
-    }
-    const updatedUser = await getService("user").updateById(id, input);
-    if (!updatedUser) {
-      return ctx.notFound("User does not exist");
-    }
-    ctx.body = {
-      data: getService("user").sanitizeUser(updatedUser)
-    };
-  },
-  async isSSOLocked(ctx) {
-    const { user: user2 } = ctx.state;
-    const isSSOLocked = await isSsoLocked(user2);
-    ctx.body = {
-      data: {
-        isSSOLocked
-      }
-    };
-  }
-};
-const admin = {
-  // NOTE: Overrides CE admin controller
-  async getProjectType() {
-    const flags = strapi.config.get("admin.flags", {});
-    try {
-      return { data: { isEE: strapi.EE, features: strapi.ee.features.list(), flags } };
-    } catch (err) {
-      return { data: { isEE: false, features: [], flags } };
-    }
-  },
-  async licenseLimitInformation() {
-    const permittedSeats = strapi.ee.seats;
-    let shouldNotify = false;
-    let licenseLimitStatus = null;
-    let enforcementUserCount;
-    const currentActiveUserCount = await getService("user").getCurrentActiveUserCount();
-    const eeDisabledUsers = await getService("seat-enforcement").getDisabledUserList();
-    if (eeDisabledUsers) {
-      enforcementUserCount = currentActiveUserCount + eeDisabledUsers.length;
-    } else {
-      enforcementUserCount = currentActiveUserCount;
-    }
-    if (!fp.isNil(permittedSeats) && enforcementUserCount > permittedSeats) {
-      shouldNotify = true;
-      licenseLimitStatus = "OVER_LIMIT";
-    }
-    if (!fp.isNil(permittedSeats) && enforcementUserCount === permittedSeats) {
-      shouldNotify = true;
-      licenseLimitStatus = "AT_LIMIT";
-    }
-    const data = {
-      enforcementUserCount,
-      currentActiveUserCount,
-      permittedSeats,
-      shouldNotify,
-      shouldStopCreate: fp.isNil(permittedSeats) ? false : currentActiveUserCount >= permittedSeats,
-      licenseLimitStatus,
-      isHostedOnStrapiCloud: utils$1.env("STRAPI_HOSTING", null) === "strapi.cloud",
-      features: strapi.ee.features.list() ?? []
-    };
-    return { data };
-  }
-};
-const controllers = {
-  authentication,
-  role,
-  user,
-  admin
-};
-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 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