@directus/api 21.0.0-rc.0 → 21.0.0

package/dist/utils/fetch-user-count/fetch-user-count.js

@@ -1,57 +0,0 @@
-import { toBoolean } from '@directus/utils';
-import { fetchAccessLookup } from './fetch-access-lookup.js';
-import { fetchAccessRoles } from './fetch-access-roles.js';
-import { getUserCountQuery } from './get-user-count-query.js';
-/**
- * Returns counts of all active users in the system grouped by admin, app, and api access
- */
-export async function fetchUserCount(options) {
-    const accessRows = await fetchAccessLookup(options);
-    const adminRoles = new Set(accessRows.filter((row) => toBoolean(row.admin_access) && row.role !== null).map((row) => row.role));
-    const appRoles = new Set(accessRows
-        .filter((row) => !toBoolean(row.admin_access) && toBoolean(row.app_access) && row.role !== null)
-        .map((row) => row.role));
-    // All users that are directly granted rights through a connected policy
-    const adminUsers = new Set(accessRows.filter((row) => toBoolean(row.admin_access) && row.user !== null).map((row) => row.user));
-    // Some roles might be granted access rights through nesting, so determine all roles that grant admin or app access,
-    // including nested roles
-    const { adminRoles: allAdminRoles, appRoles: allAppRoles } = await fetchAccessRoles({
-        adminRoles,
-        appRoles,
-        ...options,
-    }, { knex: options.knex });
-    // All users that are granted admin rights through a role, but not directly
-    const adminCountQuery = getUserCountQuery(options.knex, {
-        includeRoles: Array.from(allAdminRoles),
-        excludeIds: [...adminUsers, ...(options.excludeUsers ?? [])],
-    });
-    if (options.adminOnly) {
-        // Shortcut for only counting admin users
-        const adminResult = await adminCountQuery;
-        return {
-            admin: Number(adminResult?.['count'] ?? 0) + adminUsers.size,
-            app: 0,
-            api: 0,
-        };
-    }
-    const appUsers = new Set(accessRows
-        .filter((row) => !toBoolean(row.admin_access) && toBoolean(row.app_access) && row.user !== null)
-        .map((row) => row.user));
-    // All users that are granted app rights through a role, but not directly, and that aren't admin users
-    const appCountQuery = getUserCountQuery(options.knex, {
-        includeRoles: Array.from(allAppRoles),
-        excludeRoles: Array.from(allAdminRoles),
-        excludeIds: [...appUsers, ...adminUsers, ...(options.excludeUsers ?? [])],
-    });
-    const allCountQuery = getUserCountQuery(options.knex, {
-        excludeIds: options.excludeUsers ?? [],
-    });
-    const [adminResult, appResult, allResult] = await Promise.all([adminCountQuery, appCountQuery, allCountQuery]);
-    const adminCount = Number(adminResult?.['count'] ?? 0) + adminUsers.size;
-    const appCount = Number(appResult?.['count'] ?? 0) + appUsers.size;
-    return {
-        admin: adminCount,
-        app: appCount,
-        api: Number(allResult?.['count'] ?? 0) - adminCount - appCount,
-    };
-}

package/dist/utils/fetch-user-count/get-user-count-query.d.ts

@@ -1,20 +0,0 @@
-import type { PrimaryKey } from '@directus/types';
-import type { Knex } from 'knex';
-export interface GetUserCountOptions {
-    excludeIds?: PrimaryKey[];
-    excludeRoles?: PrimaryKey[];
-    includeRoles?: PrimaryKey[];
-}
-export declare function getUserCountQuery(knex: Knex, options: GetUserCountOptions): Promise<{
-    count: number;
-}> | Knex.QueryBuilder<any, {
-    _base: {};
-    _hasSelection: true;
-    _keys: never;
-    _aliases: {};
-    _single: false;
-    _intersectProps: {
-        count?: string | number;
-    };
-    _unionProps: undefined;
-}>;

package/dist/utils/fetch-user-count/get-user-count-query.js

@@ -1,17 +0,0 @@
-export function getUserCountQuery(knex, options) {
-    // Safety check for an empty list of includeRoles, which would otherwise return all users
-    if (options.includeRoles && options.includeRoles.length === 0) {
-        return Promise.resolve({ count: 0 });
-    }
-    let query = knex('directus_users').count({ count: '*' }).as('count').where('status', 'active');
-    if (options.excludeIds && options.excludeIds.length > 0) {
-        query = query.whereNotIn('id', options.excludeIds);
-    }
-    if (options.excludeRoles && options.excludeRoles.length > 0) {
-        query = query.whereNotIn('role', options.excludeRoles);
-    }
-    if (options.includeRoles && options.includeRoles.length > 0) {
-        query = query.whereIn('role', options.includeRoles);
-    }
-    return query.first();
-}

package/dist/utils/validate-user-count-integrity.d.ts

@@ -1,13 +0,0 @@
-import { type FetchUserCountOptions } from './fetch-user-count/fetch-user-count.js';
-export declare enum UserIntegrityCheckFlag {
-    None = 0,
-    /** Check if the number of remaining admin users is greater than 0 */
-    RemainingAdmins = 1,
-    /** Check if the number of users is within the limits */
-    UserLimits = 2,
-    All = 3
-}
-export interface ValidateUserCountIntegrityOptions extends Omit<FetchUserCountOptions, 'adminOnly'> {
-    flags: UserIntegrityCheckFlag;
-}
-export declare function validateUserCountIntegrity(options: ValidateUserCountIntegrityOptions): Promise<void>;

package/dist/utils/validate-user-count-integrity.js

@@ -1,29 +0,0 @@
-import { validateRemainingAdminCount } from '../permissions/modules/validate-remaining-admin/validate-remaining-admin-count.js';
-import { checkUserLimits } from '../telemetry/utils/check-user-limits.js';
-import { shouldCheckUserLimits } from '../telemetry/utils/should-check-user-limits.js';
-import { fetchUserCount } from './fetch-user-count/fetch-user-count.js';
-export var UserIntegrityCheckFlag;
-(function (UserIntegrityCheckFlag) {
-    UserIntegrityCheckFlag[UserIntegrityCheckFlag["None"] = 0] = "None";
-    /** Check if the number of remaining admin users is greater than 0 */
-    UserIntegrityCheckFlag[UserIntegrityCheckFlag["RemainingAdmins"] = 1] = "RemainingAdmins";
-    /** Check if the number of users is within the limits */
-    UserIntegrityCheckFlag[UserIntegrityCheckFlag["UserLimits"] = 2] = "UserLimits";
-    UserIntegrityCheckFlag[UserIntegrityCheckFlag["All"] = 3] = "All";
-})(UserIntegrityCheckFlag || (UserIntegrityCheckFlag = {}));
-export async function validateUserCountIntegrity(options) {
-    const validateUserLimits = (options.flags & UserIntegrityCheckFlag.UserLimits) !== 0;
-    const validateRemainingAdminUsers = (options.flags & UserIntegrityCheckFlag.RemainingAdmins) !== 0;
-    const limitCheck = validateUserLimits && shouldCheckUserLimits();
-    if (!validateRemainingAdminUsers && !limitCheck) {
-        return;
-    }
-    const adminOnly = validateRemainingAdminUsers && !limitCheck;
-    const userCounts = await fetchUserCount({ ...options, adminOnly });
-    if (limitCheck) {
-        await checkUserLimits(userCounts);
-    }
-    if (validateRemainingAdminUsers) {
-        validateRemainingAdminCount(userCounts.admin);
-    }
-}