@strapi/admin 4.15.0 → 4.15.2

package/dist/cli.mjs

@@ -0,0 +1,48 @@
+import { b, i, d } from "./_chunks/index-44360544.mjs";
+import "@strapi/typescript-utils";
+import "node:os";
+import "node:fs/promises";
+import "node:path";
+import "inquirer";
+import "semver";
+import "resolve-from";
+import "execa";
+import "read-pkg-up";
+import "outdent";
+import "prettier";
+import "react";
+import "react-dom/server";
+import "react/jsx-runtime";
+import "webpack";
+import "browserslist-to-esbuild";
+import "esbuild-loader";
+import "html-webpack-plugin";
+import "mini-css-extract-plugin";
+import "fork-ts-checker-webpack-plugin";
+import "webpack-bundle-analyzer";
+import "node:crypto";
+import "@pmmmwh/react-refresh-webpack-plugin";
+import "path";
+import "find-root";
+import "esbuild-register/dist/node";
+import "boxen";
+import "chalk";
+import "node:fs";
+import "lodash/camelCase";
+import "browserslist";
+import "@strapi/strapi";
+import "@strapi/utils";
+import "dotenv";
+import "@strapi/strapi/dist/utils/ee";
+import "perf_hooks";
+import "chokidar";
+import "node:cluster";
+import "node:util";
+import "webpack-dev-middleware";
+import "webpack-hot-middleware";
+export {
+  b as build,
+  i as commands,
+  d as develop
+};
+//# sourceMappingURL=cli.mjs.map

package/dist/cli.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/ee/admin/src/constants.d.ts

@@ -0,0 +1,55 @@
+import type { SettingsMenu } from '../../../admin/src/constants';
+export declare const ADMIN_PERMISSIONS_EE: {
+    settings: {
+        auditLogs: {
+            main: {
+                action: string;
+                subject: null;
+            }[];
+            read: {
+                action: string;
+                subject: null;
+            }[];
+        };
+        'review-workflows': {
+            main: {
+                action: string;
+                subject: null;
+            }[];
+            create: {
+                action: string;
+                subject: null;
+            }[];
+            delete: {
+                action: string;
+                subject: null;
+            }[];
+            update: {
+                action: string;
+                subject: null;
+            }[];
+        };
+        sso: {
+            main: {
+                action: string;
+                subject: null;
+            }[];
+            read: {
+                action: string;
+                subject: null;
+            }[];
+            update: {
+                action: string;
+                subject: null;
+            }[];
+        };
+    };
+};
+export declare const ROUTES_EE: {
+    Component: () => {
+        default: () => import("react/jsx-runtime").JSX.Element;
+    };
+    to: string;
+    exact: boolean;
+}[];
+export declare const SETTINGS_LINKS_EE: () => SettingsMenu;

package/dist/ee/admin/src/hooks/useLicenseLimitNotification.d.ts

@@ -0,0 +1 @@
+export declare const useLicenseLimitNotification: () => void;

package/dist/ee/admin/src/pages/AuthPage/components/Login.d.ts

@@ -0,0 +1,3 @@
+import { LoginProps } from '../../../../../../admin/src/pages/Auth/components/Login';
+declare const LoginEE: (loginProps: LoginProps) => import("react/jsx-runtime").JSX.Element;
+export { LoginEE };

package/dist/ee/admin/src/pages/AuthPage/components/Providers.d.ts

@@ -0,0 +1,2 @@
+declare const Providers: () => import("react/jsx-runtime").JSX.Element;
+export { Providers };

package/dist/ee/admin/src/pages/AuthPage/components/SSOProviders.d.ts

@@ -0,0 +1,8 @@
+import { GetProviders } from '../../../../../../shared/contracts/providers';
+interface SSOProvidersProps {
+    providers: GetProviders.Response;
+    displayAllProviders?: boolean;
+}
+declare const SSOProviders: ({ providers, displayAllProviders }: SSOProvidersProps) => import("react/jsx-runtime").JSX.Element;
+export { SSOProviders };
+export type { SSOProvidersProps };

package/dist/ee/admin/src/pages/AuthPage/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const FORMS: {
+    providers: () => import("react/jsx-runtime").JSX.Element;
+};

package/dist/ee/admin/src/pages/AuthResponse.d.ts

@@ -0,0 +1,2 @@
+declare const AuthResponse: () => import("react/jsx-runtime").JSX.Element;
+export { AuthResponse };

package/dist/ee/admin/src/pages/HomePage.d.ts

@@ -0,0 +1 @@
+export declare const HomePageEE: () => import("react/jsx-runtime").JSX.Element;

package/dist/shared/contracts/admin.d.ts

@@ -0,0 +1,23 @@
+import { errors } from '@strapi/utils';
+/**
+ * /information - get project information
+ */
+export declare namespace Information {
+    interface Request {
+        body: {};
+        query: {};
+    }
+    interface Response {
+        data: {
+            currentEnvironment: string;
+            autoReload: boolean;
+            strapiVersion: string | null;
+            dependencies: Record<string, string>;
+            projectId: string | null;
+            nodeVersion: string;
+            communityEdition: boolean;
+            useYarn: boolean;
+        };
+        error?: errors.ApplicationError;
+    }
+}

package/dist/shared/contracts/authentication.d.ts

@@ -0,0 +1,126 @@
+import type { AdminUser, SanitizedAdminUser } from './shared';
+import type { errors } from '@strapi/utils';
+/**
+ * /login - Log in as an admin user
+ */
+export declare namespace Login {
+    interface Request {
+        body: Pick<AdminUser, 'email' | 'password'>;
+    }
+    interface Response {
+        data: {
+            token: string;
+            user: Omit<SanitizedAdminUser, 'permissions'>;
+        };
+        errors?: errors.ApplicationError | errors.NotImplementedError;
+    }
+}
+/**
+ * /renew-token - Renew an admin user's token
+ */
+export declare namespace RenewToken {
+    interface Request {
+        body: {
+            token: string;
+        };
+    }
+    interface Response {
+        data: {
+            token: string;
+        };
+        errors?: errors.ApplicationError | errors.ValidationError;
+    }
+}
+/**
+ * /registration-info - Get the info via a registration token
+ */
+export declare namespace RegistrationInfo {
+    interface Request {
+        query: {
+            registrationToken: string;
+        };
+    }
+    interface Response {
+        data: {
+            email?: string;
+            firstname?: string;
+            lastname?: string;
+        };
+        errors?: errors.ApplicationError | errors.ValidationError;
+    }
+}
+/**
+ * /register - Register an admin user
+ */
+export declare namespace Register {
+    interface Request {
+        body: {
+            registrationToken: string;
+            userInfo: Pick<AdminUser, 'firstname' | 'lastname' | 'email' | 'password'>;
+        };
+    }
+    interface Response {
+        data: {
+            token: string;
+            user: Omit<SanitizedAdminUser, 'permissions'>;
+        };
+        errors?: errors.ApplicationError | errors.YupValidationError;
+    }
+}
+/**
+ * /register-admin - Register an admin user
+ */
+export declare namespace RegisterAdmin {
+    interface Request {
+        body: Pick<AdminUser, 'email' | 'firstname' | 'lastname' | 'password'>;
+    }
+    interface Response {
+        data: {
+            token: string;
+            user: Omit<SanitizedAdminUser, 'permissions'>;
+        };
+        errors?: errors.ApplicationError | errors.YupValidationError;
+    }
+}
+/**
+ * /forgot-password - Send a password reset email
+ */
+export declare namespace ForgotPassword {
+    interface Request {
+        body: {
+            email: string;
+        };
+    }
+    interface Response {
+    }
+}
+/**
+ * /reset-password - Reset a password
+ */
+export declare namespace ResetPassword {
+    interface Request {
+        body: {
+            resetPasswordToken: string;
+            password: string;
+        };
+    }
+    interface Response {
+        data: {
+            token: string;
+            user: Omit<SanitizedAdminUser, 'permissions'>;
+        };
+    }
+}
+/**
+ * /logout - Log out an admin user
+ */
+export declare namespace Logout {
+    interface Request {
+        query: {
+            token: string;
+        };
+    }
+    interface Response {
+        data: {};
+    }
+}

package/dist/shared/contracts/providers.d.ts

@@ -0,0 +1,34 @@
+import { errors } from '@strapi/utils';
+/**
+ * /providers/isSSOLocked
+ */
+export declare namespace IsSSOLocked {
+    interface Request {
+        body: {};
+        query: {};
+    }
+    interface Response {
+        data: {
+            isSSOLocked: boolean;
+        };
+        error?: errors.ApplicationError;
+    }
+}
+export interface Provider {
+    displayName: string;
+    icon?: string | null;
+    uid: string;
+}
+/**
+ * /providers
+ */
+export declare namespace GetProviders {
+    interface Request {
+        body: {};
+        query: {};
+    }
+    /**
+     * TODO: this should follow the expected pattern of returning `data` as an object.
+     */
+    type Response = Provider[];
+}

package/dist/shared/contracts/roles.d.ts

@@ -0,0 +1,52 @@
+import type { Entity, EntityService } from '@strapi/types';
+import type { errors } from '@strapi/utils';
+import { Permission, SanitizedAdminRole } from './shared';
+type SanitizedAdminRoleWithUsersCount = SanitizedAdminRole & {
+    usersCount?: number;
+};
+/**
+ * GET /roles/:id/permissions - Get the permissions of a role
+ */
+export declare namespace GetPermissions {
+    interface Request {
+        params: {
+            id: string;
+        };
+        query: {};
+        body: {};
+    }
+    interface Response {
+        data: Permission[];
+        error?: errors.ApplicationError | errors.NotFoundError;
+    }
+}
+/**
+ * GET /roles/:id - Find a role by ID
+ */
+export declare namespace FindOne {
+    interface Request {
+        params: {
+            id: Entity.ID;
+        };
+        query: {};
+        body: {};
+    }
+    interface Response {
+        data: SanitizedAdminRoleWithUsersCount;
+        error?: errors.ApplicationError | errors.NotFoundError;
+    }
+}
+/**
+ * GET /roles
+ */
+export declare namespace FindAll {
+    interface Request {
+        query: EntityService.Params.Pick<'admin::role', 'sort' | 'filters' | 'fields'>;
+        body: {};
+    }
+    interface Response {
+        data: SanitizedAdminRoleWithUsersCount[];
+        error?: errors.ApplicationError | errors.ValidationError;
+    }
+}
+export {};

package/dist/shared/contracts/shared.d.ts

@@ -0,0 +1,39 @@
+import type { Entity as TEntity } from '@strapi/types';
+export interface Entity {
+    id: TEntity.ID;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface Permission extends Entity {
+    action: string;
+    actionParameters: object;
+    subject?: string | null;
+    properties: {
+        fields?: string[];
+        locales?: string[];
+        [key: string]: any;
+    };
+    conditions: string[];
+}
+export interface AdminRole extends Entity {
+    name: string;
+    code: string;
+    description?: string;
+    users: AdminUser[];
+    permissions: Permission[];
+}
+export interface AdminUser extends Entity {
+    firstname?: string;
+    lastname?: string;
+    username?: string;
+    email?: string;
+    password?: string;
+    resetPasswordToken?: string | null;
+    registrationToken?: string | null;
+    isActive: boolean;
+    roles: AdminRole[];
+    blocked: boolean;
+    preferedLanguage?: string;
+}
+export type SanitizedAdminUser = Omit<AdminUser, 'password' | 'resetPasswordToken' | 'registrationToken'>;
+export type SanitizedAdminRole = Omit<AdminRole, 'users' | 'permissions'>;

package/dist/shared/contracts/user.d.ts

@@ -0,0 +1,40 @@
+import { errors } from '@strapi/utils';
+import type { SanitizedAdminUser } from './shared';
+import type { Entity, EntityService } from '@strapi/types';
+/**
+ * /find - Find admin users
+ */
+export declare namespace FindAll {
+    interface Request {
+        query: EntityService.Params.Pick<'admin::user', 'sort' | 'filters' | 'fields'>;
+        body: {};
+    }
+    interface Response {
+        data: {
+            results: SanitizedAdminUser[];
+            pagination: {
+                page: number;
+                pageSize: number;
+                pageCount: number;
+                total: number;
+            };
+        };
+        error?: errors.ApplicationError;
+    }
+}
+/**
+ * /findOne - Find an admin user
+ */
+export declare namespace FindOne {
+    interface Request {
+        body: {};
+        query: {};
+    }
+    interface Params {
+        id: Entity.ID;
+    }
+    interface Response {
+        data: SanitizedAdminUser;
+        error?: errors.ApplicationError;
+    }
+}

package/dist/shared/contracts/users.d.ts

@@ -0,0 +1,49 @@
+import type { errors } from '@strapi/utils';
+import type { SanitizedAdminUser, Permission } from './shared';
+/**
+ * GET /users/me - Log in as an admin user
+ */
+export declare namespace GetMe {
+    interface Request {
+        query: {};
+        body: {};
+    }
+    interface Response {
+        data: SanitizedAdminUser;
+        error?: errors.ApplicationError;
+    }
+}
+/**
+ * PUT /users/me - Update the current admin user
+ */
+export declare namespace UpdateMe {
+    interface Request {
+        query: {};
+        body: {
+            email?: string;
+            firstname?: string;
+            lastname?: string;
+            username?: string;
+            password?: string;
+            currentPassword?: string;
+            preferedLanguage?: string;
+        };
+    }
+    interface Response {
+        data: SanitizedAdminUser;
+        error?: errors.ApplicationError | errors.ValidationError | errors.YupValidationError;
+    }
+}
+/**
+ * GET /users/me/permissions - Get the permissions of the current admin user
+ */
+export declare namespace GetOwnPermissions {
+    interface Request {
+        query: {};
+        body: {};
+    }
+    interface Response {
+        data: Permission[];
+        error?: errors.ApplicationError;
+    }
+}

package/dist/shared/schema.d.ts

@@ -0,0 +1,7 @@
+import { Schema } from '@strapi/types';
+export interface ContentType extends Schema.ContentType {
+    isDisplayed: boolean;
+}
+export interface Component extends Schema.Component {
+    isDisplayed: boolean;
+}

package/ee/server/controllers/__tests__/stages.test.js

@@ -0,0 +1,174 @@
+'use strict';
+
+const { ENTITY_STAGE_ATTRIBUTE } = require('../../constants/workflows');
+const stages = require('../workflows/stages');
+
+describe('Stages', () => {
+  const nonExistantEntityId = 1;
+  const entityId = 2;
+
+  const numberOfStages = 4;
+  const entityStageId = 1;
+
+  const readMock = jest.fn(() => false);
+
+  global.strapi = {
+    admin: {
+      services: {
+        'stage-permissions': {
+          can: jest.fn(() => true),
+        },
+        workflows: {
+          count() {
+            return 1;
+          },
+          getAssignedWorkflow() {
+            return {
+              stages: Array.from({ length: numberOfStages }, (_, i) => ({ id: i + 1 })),
+            };
+          },
+        },
+      },
+    },
+    plugins: {
+      'content-manager': {
+        services: {
+          'permission-checker': {
+            create() {
+              return {
+                cannot: {
+                  read: readMock,
+                },
+              };
+            },
+          },
+        },
+        service(name) {
+          return this.services[name];
+        },
+      },
+    },
+    plugin(name) {
+      return this.plugins[name];
+    },
+    entityService: {
+      findOne: jest.fn((_, id) => {
+        if (id === nonExistantEntityId) {
+          return Promise.resolve(null);
+        }
+
+        return Promise.resolve({
+          id: entityId,
+          [ENTITY_STAGE_ATTRIBUTE]: { id: entityStageId },
+        });
+      }),
+    },
+  };
+
+  const modelUID = 'UID';
+
+  const baseCtx = {
+    state: {
+      userAbility: {},
+    },
+  };
+
+  describe('listAvailableStages', () => {
+    test('non existant entity', async () => {
+      const ctx = {
+        ...baseCtx,
+        params: {
+          model_uid: modelUID,
+          id: nonExistantEntityId,
+        },
+        throw(status, message) {
+          const error = new Error(message);
+          error.status = status;
+          throw error;
+        },
+      };
+
+      let error;
+      try {
+        await stages.listAvailableStages(ctx);
+      } catch (e) {
+        error = e;
+      }
+
+      expect(error).toBeDefined();
+      expect(error.status).toBe(404);
+    });
+
+    test('cannot transition', async () => {
+      global.strapi.admin.services['stage-permissions'].can.mockReturnValueOnce(false);
+
+      const ctx = {
+        ...baseCtx,
+        params: {
+          model_uid: modelUID,
+          id: entityId,
+        },
+      };
+
+      await stages.listAvailableStages(ctx);
+
+      expect(ctx.body.data.length).toBe(0);
+    });
+
+    test('cannot read', async () => {
+      readMock.mockReturnValueOnce(true);
+
+      const ctx = {
+        ...baseCtx,
+        params: {
+          model_uid: modelUID,
+          id: entityId,
+        },
+        forbidden() {
+          const error = new Error();
+          error.status = 403;
+          throw error;
+        },
+      };
+
+      let error;
+      try {
+        await stages.listAvailableStages(ctx);
+      } catch (e) {
+        error = e;
+      }
+      expect(error.status).toBe(403);
+    });
+
+    test('cannot transition', async () => {
+      global.strapi.admin.services['stage-permissions'].can.mockReturnValueOnce(false);
+
+      const ctx = {
+        ...baseCtx,
+        params: {
+          model_uid: modelUID,
+          id: entityId,
+        },
+      };
+
+      await stages.listAvailableStages(ctx);
+
+      expect(ctx.body.data.length).toBe(0);
+    });
+
+    test('can transition', async () => {
+      const ctx = {
+        ...baseCtx,
+        params: {
+          model_uid: modelUID,
+          id: entityId,
+        },
+      };
+
+      await stages.listAvailableStages(ctx);
+
+      expect(ctx.body.data.length).toBe(numberOfStages - 1);
+      expect(ctx.body.data).not.toContainEqual({ id: entityStageId });
+    });
+  });
+});