directus 9.9.0 → 9.11.0

package/dist/middleware/graphql.js

@@ -7,6 +7,7 @@ exports.parseGraphQL = void 0;
 const graphql_1 = require("graphql");
 const exceptions_1 = require("../exceptions");
 const async_handler_1 = __importDefault(require("../utils/async-handler"));
+const parse_json_1 = require("../utils/parse-json");
 exports.parseGraphQL = (0, async_handler_1.default)(async (req, res, next) => {
     if (req.method !== 'GET' && req.method !== 'POST') {
         throw new exceptions_1.MethodNotAllowedException('GraphQL only supports GET and POST requests.', { allow: ['GET', 'POST'] });
@@ -19,7 +20,7 @@ exports.parseGraphQL = (0, async_handler_1.default)(async (req, res, next) => {
         query = req.query.query || null;
         if (req.query.variables) {
             try {
-                variables = JSON.parse(req.query.variables);
+                variables = (0, parse_json_1.parseJSON)(req.query.variables);
             }
             catch {
                 throw new exceptions_1.InvalidQueryException(`Variables are invalid JSON.`);

package/dist/services/assets.js

@@ -70,9 +70,35 @@ class AssetsService {
         if (!exists)
             throw new exceptions_1.ForbiddenException();
         if (range) {
-            if (range.start >= file.filesize || (range.end && range.end >= file.filesize)) {
+            const missingRangeLimits = range.start === undefined && range.end === undefined;
+            const endBeforeStart = range.start !== undefined && range.end !== undefined && range.end <= range.start;
+            const startOverflow = range.start !== undefined && range.start >= file.filesize;
+            const endUnderflow = range.end !== undefined && range.end <= 0;
+            if (missingRangeLimits || endBeforeStart || startOverflow || endUnderflow) {
                 throw new exceptions_1.RangeNotSatisfiableException(range);
             }
+            const lastByte = file.filesize - 1;
+            if (range.end) {
+                if (range.start === undefined) {
+                    // fetch chunk from tail
+                    range.start = file.filesize - range.end;
+                    range.end = lastByte;
+                }
+                if (range.end >= file.filesize) {
+                    // fetch entire file
+                    range.end = lastByte;
+                }
+            }
+            if (range.start) {
+                if (range.end === undefined) {
+                    // fetch entire file
+                    range.end = lastByte;
+                }
+                if (range.start < 0) {
+                    // fetch file from head
+                    range.start = 0;
+                }
+            }
         }
         const type = file.type;
         const transforms = TransformationUtils.resolvePreset(transformation, file);

package/dist/services/authentication.js

@@ -45,7 +45,6 @@ class AuthenticationService {
             .from('directus_users as u')
             .leftJoin('directus_roles as r', 'u.role', 'r.id')
             .where('u.id', await provider.getUserID((0, lodash_1.cloneDeep)(payload)))
-            .andWhere('u.provider', providerName)
             .first();
         const updatedPayload = await emitter_1.default.emitFilter('auth.login', payload, {
             status: 'pending',
@@ -79,6 +78,10 @@ class AuthenticationService {
                 throw new exceptions_1.InvalidCredentialsException();
             }
         }
+        else if (user.provider !== providerName) {
+            await (0, stall_1.stall)(STALL_TIME, timeStart);
+            throw new exceptions_1.InvalidProviderException();
+        }
         const settingsService = new settings_1.SettingsService({
             knex: this.knex,
             schema: this.schema,

package/dist/services/collections.js

@@ -239,6 +239,8 @@ class CollectionsService {
      */
     async readOne(collectionKey) {
         const result = await this.readMany([collectionKey]);
+        if (result.length === 0)
+            throw new exceptions_1.ForbiddenException();
         return result[0];
     }
     /**

package/dist/services/fields.js

@@ -195,6 +195,8 @@ class FieldsService {
         catch {
             // Do nothing
         }
+        if (!column && !fieldInfo)
+            throw new exceptions_1.ForbiddenException();
         const type = (0, get_local_type_1.default)(column, fieldInfo);
         const data = {
             collection,
@@ -349,13 +351,6 @@ class FieldsService {
             });
             await this.knex.transaction(async (trx) => {
                 var _a, _b;
-                if (this.schema.collections[collection] &&
-                    field in this.schema.collections[collection].fields &&
-                    this.schema.collections[collection].fields[field].alias === false) {
-                    await trx.schema.table(collection, (table) => {
-                        table.dropColumn(field);
-                    });
-                }
                 const relations = this.schema.relations.filter((relation) => {
                     var _a;
                     return ((relation.collection === collection && relation.field === field) ||
@@ -387,6 +382,14 @@ class FieldsService {
                             .where({ many_collection: relation.collection, many_field: relation.field });
                     }
                 }
+                // Delete field only after foreign key constraints are removed
+                if (this.schema.collections[collection] &&
+                    field in this.schema.collections[collection].fields &&
+                    this.schema.collections[collection].fields[field].alias === false) {
+                    await trx.schema.table(collection, (table) => {
+                        table.dropColumn(field);
+                    });
+                }
                 const collectionMeta = await trx
                     .select('archive_field', 'sort_field')
                     .from('directus_collections')
@@ -439,7 +442,13 @@ class FieldsService {
         if (field.type === 'alias' || field.type === 'unknown')
             return;
         if ((_a = field.schema) === null || _a === void 0 ? void 0 : _a.has_auto_increment) {
-            column = table.increments(field.field);
+            if (field.type === 'bigInteger') {
+                // Create an auto-incremented big integer (MySQL, PostgreSQL) or an auto-incremented integer (other DBs)
+                column = table.bigIncrements(field.field);
+            }
+            else {
+                column = table.increments(field.field);
+            }
         }
         else if (field.type === 'string') {
             column = table.string(field.field, (_c = (_b = field.schema) === null || _b === void 0 ? void 0 : _b.max_length) !== null && _c !== void 0 ? _c : undefined);

package/dist/services/graphql.js

@@ -89,7 +89,16 @@ class GraphQLService {
     async execute({ document, variables, operationName, contextValue, }) {
         var _a;
         const schema = this.getSchema();
-        const validationErrors = (0, graphql_1.validate)(schema, document, graphql_1.specifiedRules);
+        const validationErrors = (0, graphql_1.validate)(schema, document, [
+            ...graphql_1.specifiedRules,
+            (context) => ({
+                Field(node) {
+                    if (env_1.default.GRAPHQL_INTROSPECTION === false && (node.name.value === '__schema' || node.name.value === '__type')) {
+                        context.reportError(new graphql_1.GraphQLError('GraphQL introspection is not allowed. The query contained __schema or __type.', [node]));
+                    }
+                },
+            }),
+        ]);
         if (validationErrors.length > 0) {
             throw new exceptions_1.GraphQLValidationException({ graphqlErrors: validationErrors });
         }
@@ -161,16 +170,7 @@ class GraphQLService {
                 acc[collectionName] = ReadCollectionTypes[collection.collection].getResolver(collection.collection);
                 if (this.schema.collections[collection.collection].singleton === false) {
                     acc[`${collectionName}_by_id`] = ReadCollectionTypes[collection.collection].getResolver(`${collection.collection}_by_id`);
-                    const hasAggregate = Object.values(collection.fields).some((field) => {
-                        const graphqlType = (0, get_graphql_type_1.getGraphQLType)(field.type);
-                        if (graphqlType === graphql_1.GraphQLInt || graphqlType === graphql_1.GraphQLFloat) {
-                            return true;
-                        }
-                        return false;
-                    });
-                    if (hasAggregate) {
-                        acc[`${collectionName}_aggregated`] = ReadCollectionTypes[collection.collection].getResolver(`${collection.collection}_aggregated`);
-                    }
+                    acc[`${collectionName}_aggregated`] = ReadCollectionTypes[collection.collection].getResolver(`${collection.collection}_aggregated`);
                 }
                 return acc;
             }, {}));
@@ -415,7 +415,8 @@ class GraphQLService {
             const { CollectionTypes: ReadCollectionTypes } = getTypes('read');
             const ReadableCollectionFilterTypes = {};
             const AggregatedFunctions = {};
-            const AggregatedFilters = {};
+            const AggregatedFields = {};
+            const AggregateMethods = {};
             const StringFilterOperators = schemaComposer.createInputTC({
                 name: 'string_filter_operators',
                 fields: {
@@ -671,7 +672,7 @@ class GraphQLService {
                     _and: [ReadableCollectionFilterTypes[collection.collection]],
                     _or: [ReadableCollectionFilterTypes[collection.collection]],
                 });
-                AggregatedFilters[collection.collection] = schemaComposer.createObjectTC({
+                AggregatedFields[collection.collection] = schemaComposer.createObjectTC({
                     name: `${collection.collection}_aggregated_fields`,
                     fields: Object.values(collection.fields).reduce((acc, field) => {
                         const graphqlType = (0, get_graphql_type_1.getGraphQLType)(field.type);
@@ -689,46 +690,71 @@ class GraphQLService {
                         return acc;
                     }, {}),
                 });
-                AggregatedFunctions[collection.collection] = schemaComposer.createObjectTC({
-                    name: `${collection.collection}_aggregated`,
-                    fields: {
-                        group: {
-                            name: 'group',
-                            type: graphql_compose_1.GraphQLJSON,
-                        },
+                AggregateMethods[collection.collection] = {
+                    group: {
+                        name: 'group',
+                        type: graphql_compose_1.GraphQLJSON,
+                    },
+                    countAll: {
+                        name: 'countAll',
+                        type: graphql_1.GraphQLInt,
+                    },
+                    count: {
+                        name: 'count',
+                        type: schemaComposer.createObjectTC({
+                            name: `${collection.collection}_aggregated_count`,
+                            fields: Object.values(collection.fields).reduce((acc, field) => {
+                                acc[field.field] = {
+                                    type: graphql_1.GraphQLInt,
+                                    description: field.note,
+                                };
+                                return acc;
+                            }, {}),
+                        }),
+                    },
+                };
+                const hasNumericAggregates = Object.values(collection.fields).some((field) => {
+                    const graphqlType = (0, get_graphql_type_1.getGraphQLType)(field.type);
+                    if (graphqlType === graphql_1.GraphQLInt || graphqlType === graphql_1.GraphQLFloat) {
+                        return true;
+                    }
+                    return false;
+                });
+                if (hasNumericAggregates) {
+                    Object.assign(AggregateMethods[collection.collection], {
                         avg: {
                             name: 'avg',
-                            type: AggregatedFilters[collection.collection],
+                            type: AggregatedFields[collection.collection],
                         },
                         sum: {
                             name: 'sum',
-                            type: AggregatedFilters[collection.collection],
-                        },
-                        count: {
-                            name: 'count',
-                            type: AggregatedFilters[collection.collection],
+                            type: AggregatedFields[collection.collection],
                         },
                         countDistinct: {
                             name: 'countDistinct',
-                            type: AggregatedFilters[collection.collection],
+                            type: AggregatedFields[collection.collection],
                         },
                         avgDistinct: {
                             name: 'avgDistinct',
-                            type: AggregatedFilters[collection.collection],
+                            type: AggregatedFields[collection.collection],
                         },
                         sumDistinct: {
                             name: 'sumDistinct',
-                            type: AggregatedFilters[collection.collection],
+                            type: AggregatedFields[collection.collection],
                         },
                         min: {
                             name: 'min',
-                            type: AggregatedFilters[collection.collection],
+                            type: AggregatedFields[collection.collection],
                         },
                         max: {
                             name: 'max',
-                            type: AggregatedFilters[collection.collection],
+                            type: AggregatedFields[collection.collection],
                         },
-                    },
+                    });
+                }
+                AggregatedFunctions[collection.collection] = schemaComposer.createObjectTC({
+                    name: `${collection.collection}_aggregated`,
+                    fields: AggregateMethods[collection.collection],
                 });
                 ReadCollectionTypes[collection.collection].addResolver({
                     name: collection.collection,
@@ -1175,6 +1201,7 @@ class GraphQLService {
                     continue;
                 selection = selection;
                 let current;
+                let currentAlias = null;
                 // Union type (Many-to-Any)
                 if (selection.kind === 'InlineFragment') {
                     if (selection.typeCondition.name.value.startsWith('__'))
@@ -1187,8 +1214,20 @@ class GraphQLService {
                     if (selection.name.value.startsWith('__'))
                         continue;
                     current = selection.name.value;
+                    if (selection.alias) {
+                        currentAlias = selection.alias.value;
+                    }
                     if (parent) {
                         current = `${parent}.${current}`;
+                        if (currentAlias) {
+                            currentAlias = `${parent}.${currentAlias}`;
+                            // add nested aliases into deep query
+                            if (selection.selectionSet) {
+                                if (!query.deep)
+                                    query.deep = {};
+                                (0, lodash_1.set)(query.deep, parent, (0, lodash_1.merge)((0, lodash_1.get)(query.deep, parent), { _alias: { [selection.alias.value]: selection.name.value } }));
+                            }
+                        }
                     }
                 }
                 if (selection.selectionSet) {
@@ -1203,7 +1242,7 @@ class GraphQLService {
                         }
                     }
                     else {
-                        children = parseFields(selection.selectionSet.selections, current);
+                        children = parseFields(selection.selectionSet.selections, currentAlias !== null && currentAlias !== void 0 ? currentAlias : current);
                     }
                     fields.push(...children);
                 }
@@ -1215,7 +1254,7 @@ class GraphQLService {
                         if (!query.deep)
                             query.deep = {};
                         const args = this.parseArgs(selection.arguments, variableValues);
-                        (0, lodash_1.set)(query.deep, current, (0, lodash_1.merge)((0, lodash_1.get)(query.deep, current), (0, lodash_1.mapKeys)((0, sanitize_query_1.sanitizeQuery)(args, this.accountability), (value, key) => `_${key}`)));
+                        (0, lodash_1.set)(query.deep, currentAlias !== null && currentAlias !== void 0 ? currentAlias : current, (0, lodash_1.merge)((0, lodash_1.get)(query.deep, currentAlias !== null && currentAlias !== void 0 ? currentAlias : current), (0, lodash_1.mapKeys)((0, sanitize_query_1.sanitizeQuery)(args, this.accountability), (value, key) => `_${key}`)));
                     }
                 }
             }
@@ -1274,8 +1313,10 @@ class GraphQLService {
      */
     formatError(error) {
         if (Array.isArray(error)) {
+            error[0].extensions.code = error[0].code;
             return new graphql_1.GraphQLError(error[0].message, undefined, undefined, undefined, undefined, error[0]);
         }
+        error.extensions.code = error.code;
         return new graphql_1.GraphQLError(error.message, undefined, undefined, undefined, undefined, error);
     }
     /**

package/dist/services/import-export.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" />
+import { Accountability, Query, SchemaOverview } from '@directus/shared/types';
 import { Knex } from 'knex';
 import { AbstractServiceOptions, File } from '../types';
-import { Accountability, Query, SchemaOverview } from '@directus/shared/types';
 export declare class ImportService {
     knex: Knex;
     accountability: Accountability | null;

package/dist/services/import-export.js

@@ -4,24 +4,26 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExportService = exports.ImportService = void 0;
-const database_1 = __importDefault(require("../database"));
-const exceptions_1 = require("../exceptions");
-const StreamArray_1 = __importDefault(require("stream-json/streamers/StreamArray"));
-const items_1 = require("./items");
+const utils_1 = require("@directus/shared/utils");
 const async_1 = require("async");
-const destroy_1 = __importDefault(require("destroy"));
 const csv_parser_1 = __importDefault(require("csv-parser"));
-const lodash_1 = require("lodash");
+const destroy_1 = __importDefault(require("destroy"));
+const fs_extra_1 = require("fs-extra");
 const js2xmlparser_1 = require("js2xmlparser");
 const json2csv_1 = require("json2csv");
-const fs_extra_1 = require("fs-extra");
+const lodash_1 = require("lodash");
+const StreamArray_1 = __importDefault(require("stream-json/streamers/StreamArray"));
+const strip_bom_stream_1 = __importDefault(require("strip-bom-stream"));
 const tmp_promise_1 = require("tmp-promise");
+const database_1 = __importDefault(require("../database"));
 const env_1 = __importDefault(require("../env"));
-const files_1 = require("./files");
+const exceptions_1 = require("../exceptions");
+const logger_1 = __importDefault(require("../logger"));
 const get_date_formatted_1 = require("../utils/get-date-formatted");
-const utils_1 = require("@directus/shared/utils");
+const parse_json_1 = require("../utils/parse-json");
+const files_1 = require("./files");
+const items_1 = require("./items");
 const notifications_1 = require("./notifications");
-const logger_1 = __importDefault(require("../logger"));
 class ImportService {
     constructor(options) {
         this.knex = options.knex || (0, database_1.default)();
@@ -91,6 +93,7 @@ class ImportService {
             });
             return new Promise((resolve, reject) => {
                 stream
+                    .pipe((0, strip_bom_stream_1.default)())
                     .pipe((0, csv_parser_1.default)())
                     .on('data', (value) => {
                     const obj = (0, lodash_1.transform)(value, (result, value, key) => {
@@ -99,7 +102,7 @@ class ImportService {
                         }
                         else {
                             try {
-                                const parsedJson = JSON.parse(value);
+                                const parsedJson = (0, parse_json_1.parseJSON)(value);
                                 (0, lodash_1.set)(result, key, parsedJson);
                             }
                             catch {

package/dist/services/items.d.ts

@@ -1,7 +1,7 @@
-import { Knex } from 'knex';
+import { Accountability, PermissionsAction, Query, SchemaOverview } from '@directus/shared/types';
 import Keyv from 'keyv';
-import { Accountability, Query, PermissionsAction, SchemaOverview } from '@directus/shared/types';
-import { AbstractService, AbstractServiceOptions, Item as AnyItem, PrimaryKey, MutationOptions } from '../types';
+import { Knex } from 'knex';
+import { AbstractService, AbstractServiceOptions, Item as AnyItem, MutationOptions, PrimaryKey } from '../types';
 export declare type QueryOptions = {
     stripNonRequested?: boolean;
     permissionsAction?: PermissionsAction;

package/dist/services/items.js

@@ -15,8 +15,8 @@ const translate_1 = require("../exceptions/database/translate");
 const types_1 = require("../types");
 const get_ast_from_query_1 = __importDefault(require("../utils/get-ast-from-query"));
 const authorization_1 = require("./authorization");
-const payload_1 = require("./payload");
 const index_1 = require("./index");
+const payload_1 = require("./payload");
 class ItemsService {
     constructor(collection, options) {
         this.collection = collection;
@@ -90,8 +90,13 @@ class ItemsService {
             // In case of manual string / UUID primary keys, the PK already exists in the object we're saving.
             let primaryKey = payloadWithTypeCasting[primaryKeyField];
             try {
-                const result = await trx.insert(payloadWithoutAliases).into(this.collection).returning(primaryKeyField);
-                primaryKey = primaryKey !== null && primaryKey !== void 0 ? primaryKey : result[0];
+                const result = await trx
+                    .insert(payloadWithoutAliases)
+                    .into(this.collection)
+                    .returning(primaryKeyField)
+                    .then((result) => result[0]);
+                const returnedKey = typeof result === 'object' ? result[primaryKeyField] : result;
+                primaryKey = primaryKey !== null && primaryKey !== void 0 ? primaryKey : returnedKey;
             }
             catch (err) {
                 throw await (0, translate_1.translateDatabaseError)(err);
@@ -255,6 +260,10 @@ class ItemsService {
         const primaryKeyField = this.schema.collections[this.collection].primary;
         const filterWithKey = { _and: [{ [primaryKeyField]: { _in: keys } }, (_a = query.filter) !== null && _a !== void 0 ? _a : {}] };
         const queryWithKey = (0, lodash_1.assign)({}, query, { filter: filterWithKey });
+        // Set query limit as the number of keys
+        if (Array.isArray(keys) && keys.length > 0 && !queryWithKey.limit) {
+            queryWithKey.limit = keys.length;
+        }
         const results = await this.readByQuery(queryWithKey, opts);
         return results;
     }
@@ -301,6 +310,8 @@ class ItemsService {
                 accountability: this.accountability,
             })
             : payload;
+        // Sort keys to ensure that the order is maintained
+        keys.sort();
         if (this.accountability) {
             await authorizationService.checkAccess('update', this.collection, keys);
         }
@@ -354,13 +365,14 @@ class ItemsService {
                         knex: trx,
                         schema: this.schema,
                     });
-                    const revisionIDs = await revisionsService.createMany(await Promise.all(activity.map(async (activity, index) => ({
+                    const revisions = (await Promise.all(activity.map(async (activity, index) => ({
                         activity: activity,
                         collection: this.collection,
                         item: keys[index],
                         data: snapshots && Array.isArray(snapshots) ? JSON.stringify(snapshots[index]) : JSON.stringify(snapshots),
                         delta: await payloadService.prepareDelta(payloadWithTypeCasting),
-                    }))));
+                    })))).filter((revision) => revision.delta);
+                    const revisionIDs = await revisionsService.createMany(revisions);
                     for (let i = 0; i < revisionIDs.length; i++) {
                         const revisionID = revisionIDs[i];
                         if (opts === null || opts === void 0 ? void 0 : opts.onRevisionCreate) {
@@ -461,6 +473,7 @@ class ItemsService {
             const authorizationService = new authorization_1.AuthorizationService({
                 accountability: this.accountability,
                 schema: this.schema,
+                knex: this.knex,
             });
             await authorizationService.checkAccess('delete', this.collection, keys);
         }
@@ -529,7 +542,8 @@ class ItemsService {
                     defaults[name] = null;
                     continue;
                 }
-                defaults[name] = field.defaultValue;
+                if (field.defaultValue)
+                    defaults[name] = field.defaultValue;
             }
             return defaults;
         }

package/dist/services/payload.d.ts

@@ -1,7 +1,7 @@
-import { Knex } from 'knex';
-import { AbstractServiceOptions, Item, PrimaryKey } from '../types';
 import { Accountability, SchemaOverview } from '@directus/shared/types';
+import { Knex } from 'knex';
 import { Helpers } from '../database/helpers';
+import { AbstractServiceOptions, Item, PrimaryKey } from '../types';
 declare type Action = 'create' | 'read' | 'update';
 declare type Transformers = {
     [type: string]: (context: {
@@ -65,6 +65,6 @@ export declare class PayloadService {
      * Transforms the input partial payload to match the output structure, to have consistency
      * between delta and data
      */
-    prepareDelta(data: Partial<Item>): Promise<string>;
+    prepareDelta(data: Partial<Item>): Promise<string | null>;
 }
 export {};

package/dist/services/payload.js

@@ -4,18 +4,19 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PayloadService = void 0;
+const utils_1 = require("@directus/shared/utils");
 const date_fns_1 = require("date-fns");
+const flat_1 = require("flat");
 const joi_1 = __importDefault(require("joi"));
 const lodash_1 = require("lodash");
 const uuid_1 = require("uuid");
+const wellknown_1 = require("wellknown");
 const database_1 = __importDefault(require("../database"));
-const exceptions_1 = require("../exceptions");
-const utils_1 = require("@directus/shared/utils");
-const items_1 = require("./items");
-const flat_1 = require("flat");
 const helpers_1 = require("../database/helpers");
-const wellknown_1 = require("wellknown");
+const exceptions_1 = require("../exceptions");
 const generate_hash_1 = require("../utils/generate-hash");
+const parse_json_1 = require("../utils/parse-json");
+const items_1 = require("./items");
 /**
  * Process a given payload for a collection to ensure the special fields (hash, uuid, date etc) are
  * handled correctly.
@@ -55,7 +56,7 @@ class PayloadService {
                 if (action === 'read') {
                     if (typeof value === 'string') {
                         try {
-                            return JSON.parse(value);
+                            return (0, parse_json_1.parseJSON)(value);
                         }
                         catch {
                             return value;
@@ -196,7 +197,7 @@ class PayloadService {
     processGeometries(payloads, action) {
         const process = action == 'read'
             ? (value) => (typeof value === 'string' ? (0, wellknown_1.parse)(value) : value)
-            : (value) => this.helpers.st.fromGeoJSON(typeof value == 'string' ? JSON.parse(value) : value);
+            : (value) => this.helpers.st.fromGeoJSON(typeof value == 'string' ? (0, parse_json_1.parseJSON)(value) : value);
         const fieldsInCollection = Object.entries(this.schema.collections[this.collection].fields);
         const geometryColumns = fieldsInCollection.filter(([_, field]) => field.type.startsWith('geometry'));
         for (const [name] of geometryColumns) {
@@ -318,7 +319,7 @@ class PayloadService {
             }
             const allowedCollections = relation.meta.one_allowed_collections;
             if (allowedCollections.includes(relatedCollection) === false) {
-                throw new exceptions_1.InvalidPayloadException(`"${relation.collection}.${relation.field}" can't be linked to collection "${relatedCollection}`);
+                throw new exceptions_1.InvalidPayloadException(`"${relation.collection}.${relation.field}" can't be linked to collection "${relatedCollection}"`);
             }
             const itemsService = new items_1.ItemsService(relatedCollection, {
                 accountability: this.accountability,
@@ -578,6 +579,8 @@ class PayloadService {
             }
         }
         payload = await this.processValues('read', payload);
+        if (Object.keys(payload).length === 0)
+            return null;
         return JSON.stringify(payload);
     }
 }

package/dist/services/specifications.js

@@ -315,9 +315,7 @@ class OASSpecsService {
                                                     schema: {
                                                         properties: {
                                                             data: {
-                                                                items: {
-                                                                    $ref: `#/components/schemas/${tag.name}`,
-                                                                },
+                                                                $ref: `#/components/schemas/${tag.name}`,
                                                             },
                                                         },
                                                     },

package/dist/services/users.d.ts

@@ -18,6 +18,10 @@ export declare class UsersService extends ItemsService {
      */
     private checkPasswordPolicy;
     private checkRemainingAdminExistence;
+    /**
+     * Make sure there's at least one active admin user when updating user status
+     */
+    private checkRemainingActiveAdmin;
     /**
      * Create a new user
      */

package/dist/services/users.js

@@ -101,6 +101,23 @@ class UsersService extends items_1.ItemsService {
             throw new exceptions_2.UnprocessableEntityException(`You can't remove the last admin user from the role.`);
         }
     }
+    /**
+     * Make sure there's at least one active admin user when updating user status
+     */
+    async checkRemainingActiveAdmin(excludeKeys) {
+        const otherAdminUsers = await this.knex
+            .count('*', { as: 'count' })
+            .from('directus_users')
+            .whereNotIn('directus_users.id', excludeKeys)
+            .andWhere({ 'directus_roles.admin_access': true })
+            .andWhere({ 'directus_users.status': 'active' })
+            .leftJoin('directus_roles', 'directus_users.role', 'directus_roles.id')
+            .first();
+        const otherAdminUsersCount = +((otherAdminUsers === null || otherAdminUsers === void 0 ? void 0 : otherAdminUsers.count) || 0);
+        if (otherAdminUsersCount === 0) {
+            throw new exceptions_2.UnprocessableEntityException(`You can't change the active status of the last admin user.`);
+        }
+    }
     /**
      * Create a new user
      */
@@ -140,12 +157,18 @@ class UsersService extends items_1.ItemsService {
      * Update many users by primary key
      */
     async updateMany(keys, data, opts) {
+        var _a, _b;
         if (data.role) {
-            const newRole = await this.knex.select('admin_access').from('directus_roles').where('id', data.role).first();
+            // data.role will be an object with id with GraphQL mutations
+            const roleId = (_b = (_a = data.role) === null || _a === void 0 ? void 0 : _a.id) !== null && _b !== void 0 ? _b : data.role;
+            const newRole = await this.knex.select('admin_access').from('directus_roles').where('id', roleId).first();
             if (!(newRole === null || newRole === void 0 ? void 0 : newRole.admin_access)) {
                 await this.checkRemainingAdminExistence(keys);
             }
         }
+        if (data.status !== undefined && data.status !== 'active') {
+            await this.checkRemainingActiveAdmin(keys);
+        }
         if (data.email) {
             if (keys.length > 1) {
                 throw new record_not_unique_1.RecordNotUniqueException('email', {