directus 9.2.1 → 9.4.1

package/dist/services/users.js

@@ -19,6 +19,7 @@ const mail_1 = require("./mail");
 const settings_1 = require("./settings");
 const stall_1 = require("../utils/stall");
 const perf_hooks_1 = require("perf_hooks");
+const utils_2 = require("@directus/shared/utils");
 class UsersService extends items_1.ItemsService {
     constructor(options) {
         super('directus_users', options);
@@ -251,7 +252,7 @@ class UsersService extends items_1.ItemsService {
         }
         const STALL_TIME = 500;
         const timeStart = perf_hooks_1.performance.now();
-        const user = await this.knex.select('status').from('directus_users').where({ email }).first();
+        const user = await this.knex.select('status', 'password').from('directus_users').where({ email }).first();
         if ((user === null || user === void 0 ? void 0 : user.status) !== 'active') {
             await (0, stall_1.stall)(STALL_TIME, timeStart);
             throw new exceptions_2.ForbiddenException();
@@ -261,7 +262,7 @@ class UsersService extends items_1.ItemsService {
             knex: this.knex,
             accountability: this.accountability,
         });
-        const payload = { email, scope: 'password-reset' };
+        const payload = { email, scope: 'password-reset', hash: (0, utils_2.getSimpleHash)('' + user.password) };
         const token = jsonwebtoken_1.default.sign(payload, env_1.default.SECRET, { expiresIn: '1d', issuer: 'directus' });
         const acceptURL = url ? `${url}?token=${token}` : `${env_1.default.PUBLIC_URL}/admin/reset-password?token=${token}`;
         const subjectLine = subject ? subject : 'Password Reset Request';
@@ -279,11 +280,12 @@ class UsersService extends items_1.ItemsService {
         await (0, stall_1.stall)(STALL_TIME, timeStart);
     }
     async resetPassword(token, password) {
-        const { email, scope } = jsonwebtoken_1.default.verify(token, env_1.default.SECRET, { issuer: 'directus' });
-        if (scope !== 'password-reset')
+        const { email, scope, hash } = jsonwebtoken_1.default.verify(token, env_1.default.SECRET, { issuer: 'directus' });
+        if (scope !== 'password-reset' || !hash)
             throw new exceptions_2.ForbiddenException();
-        const user = await this.knex.select('id', 'status').from('directus_users').where({ email }).first();
-        if ((user === null || user === void 0 ? void 0 : user.status) !== 'active') {
+        await this.checkPasswordPolicy([password]);
+        const user = await this.knex.select('id', 'status', 'password').from('directus_users').where({ email }).first();
+        if ((user === null || user === void 0 ? void 0 : user.status) !== 'active' || hash !== (0, utils_2.getSimpleHash)('' + user.password)) {
             throw new exceptions_2.ForbiddenException();
         }
         // Allow unauthenticated update

package/dist/services/webhooks.d.ts

@@ -1,5 +1,5 @@
-import { AbstractServiceOptions, Item, PrimaryKey, Webhook } from '../types';
-import { ItemsService, MutationOptions } from './items';
+import { AbstractServiceOptions, Item, PrimaryKey, Webhook, MutationOptions } from '../types';
+import { ItemsService } from './items';
 export declare class WebhooksService extends ItemsService<Webhook> {
     constructor(options: AbstractServiceOptions);
     createOne(data: Partial<Item>, opts?: MutationOptions): Promise<PrimaryKey>;

package/dist/tests/database/migrations/run.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/database/migrations/run.test.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const knex_1 = __importDefault(require("knex"));
+const knex_mock_client_1 = require("knex-mock-client");
+const run_1 = __importDefault(require("../../../database/migrations/run"));
+describe('run', () => {
+    let db;
+    let tracker;
+    beforeAll(() => {
+        db = (0, knex_1.default)({ client: knex_mock_client_1.MockClient });
+        tracker = (0, knex_mock_client_1.getTracker)();
+    });
+    afterEach(() => {
+        tracker.reset();
+    });
+    describe('when passed the argument up', () => {
+        it('returns "Nothing To Updage" if no directus_migrations', async () => {
+            // note the difference between an empty array and ['Empty']
+            tracker.on.select('directus_migrations').response(['Empty']);
+            await (0, run_1.default)(db, 'up').catch((e) => {
+                expect(e).toBeInstanceOf(Error);
+                expect(e.message).toBe('Nothing to upgrade');
+            });
+        });
+    });
+});

package/dist/types/ast.d.ts

@@ -10,8 +10,8 @@ export declare type M2ONode = {
     parentKey: string;
     relatedKey: string;
 };
-export declare type M2ANode = {
-    type: 'm2a';
+export declare type A2MNode = {
+    type: 'a2o';
     names: string[];
     children: {
         [collection: string]: (NestedCollectionNode | FieldNode)[];
@@ -36,7 +36,7 @@ export declare type O2MNode = {
     parentKey: string;
     relatedKey: string;
 };
-export declare type NestedCollectionNode = M2ONode | O2MNode | M2ANode;
+export declare type NestedCollectionNode = M2ONode | O2MNode | A2MNode;
 export declare type FieldNode = {
     type: 'field';
     name: string;

package/dist/types/auth.d.ts

@@ -15,11 +15,42 @@ export interface User {
     provider: string;
     external_identifier: string | null;
     auth_data: string | Record<string, unknown> | null;
+    app_access: boolean;
+    admin_access: boolean;
 }
 export declare type AuthData = Record<string, any> | null;
 export interface Session {
     token: string;
     expires: Date;
     data: string | Record<string, unknown> | null;
+    share: string;
 }
 export declare type SessionData = Record<string, any> | null;
+export declare type DirectusTokenPayload = {
+    id?: string;
+    role: string | null;
+    app_access: boolean | number;
+    admin_access: boolean | number;
+    share?: string;
+    share_scope?: {
+        collection: string;
+        item: string;
+    };
+};
+export declare type ShareData = {
+    share_id: string;
+    share_role: string;
+    share_item: string;
+    share_collection: string;
+    share_start: Date;
+    share_end: Date;
+    share_times_used: number;
+    share_max_uses?: number;
+    share_password?: string;
+};
+export declare type LoginResult = {
+    accessToken: any;
+    refreshToken: any;
+    expires: any;
+    id?: any;
+};

package/dist/types/extensions.d.ts

@@ -5,6 +5,7 @@ import { Logger } from 'pino';
 import env from '../env';
 import * as exceptions from '../exceptions';
 import * as services from '../services';
+import { Emitter } from '../emitter';
 import { getSchema } from '../utils/get-schema';
 import { SchemaOverview } from './schema';
 export declare type ExtensionContext = {
@@ -12,6 +13,7 @@ export declare type ExtensionContext = {
     exceptions: typeof exceptions;
     database: Knex;
     env: typeof env;
+    emitter: Emitter;
     logger: Logger;
     getSchema: typeof getSchema;
 };

package/dist/types/items.d.ts

@@ -13,3 +13,17 @@ export declare type Alterations = {
     }[];
     delete: (number | string)[];
 };
+export declare type MutationOptions = {
+    /**
+     * Callback function that's fired whenever a revision is made in the mutation
+     */
+    onRevisionCreate?: (pk: PrimaryKey) => void;
+    /**
+     * Flag to disable the auto purging of the cache. Is ignored when CACHE_AUTO_PURGE isn't enabled.
+     */
+    autoPurgeCache?: false;
+    /**
+     * Allow disabling the emitting of hooks. Useful if a custom hook is fired (like files.upload)
+     */
+    emitEvents?: boolean;
+};

package/dist/utils/apply-query.d.ts

@@ -5,44 +5,6 @@ import { Aggregate, Filter, Query } from '@directus/shared/types';
  * Apply the Query to a given Knex query builder instance
  */
 export default function applyQuery(knex: Knex, collection: string, dbQuery: Knex.QueryBuilder, query: Query, schema: SchemaOverview, subQuery?: boolean): Knex.QueryBuilder;
-/**
- * Apply a given filter object to the Knex QueryBuilder instance.
- *
- * Relational nested filters, like the following example:
- *
- * ```json
- * // Fetch pages that have articles written by Rijk
- *
- * {
- *   "articles": {
- *     "author": {
- *       "name": {
- *         "_eq": "Rijk"
- *       }
- *     }
- *   }
- * }
- * ```
- *
- * are handled by joining the nested tables, and using a where statement on the top level on the
- * nested field through the join. This allows us to filter the top level items based on nested data.
- * The where on the root is done with a subquery to prevent duplicates, any nested joins are done
- * with aliases to prevent naming conflicts.
- *
- * The output SQL for the above would look something like:
- *
- * ```sql
- * SELECT *
- * FROM pages
- * WHERE
- *   pages.id in (
- *     SELECT articles.page_id AS page_id
- *     FROM articles
- *     LEFT JOIN authors AS xviqp ON articles.author = xviqp.id
- *     WHERE xviqp.name = 'Rijk'
- *   )
- * ```
- */
 export declare function applyFilter(knex: Knex, schema: SchemaOverview, rootQuery: Knex.QueryBuilder, rootFilter: Filter, collection: string, subQuery?: boolean): Knex.QueryBuilder<any, any>;
 export declare function applySearch(schema: SchemaOverview, dbQuery: Knex.QueryBuilder, searchQuery: string, collection: string): Promise<void>;
 export declare function applyAggregate(dbQuery: Knex.QueryBuilder, aggregate: Aggregate, collection: string): void;

package/dist/utils/apply-query.js

@@ -76,44 +76,44 @@ function applyQuery(knex, collection, dbQuery, query, schema, subQuery = false)
     return dbQuery;
 }
 exports.default = applyQuery;
-/**
- * Apply a given filter object to the Knex QueryBuilder instance.
- *
- * Relational nested filters, like the following example:
- *
- * ```json
- * // Fetch pages that have articles written by Rijk
- *
- * {
- *   "articles": {
- *     "author": {
- *       "name": {
- *         "_eq": "Rijk"
- *       }
- *     }
- *   }
- * }
- * ```
- *
- * are handled by joining the nested tables, and using a where statement on the top level on the
- * nested field through the join. This allows us to filter the top level items based on nested data.
- * The where on the root is done with a subquery to prevent duplicates, any nested joins are done
- * with aliases to prevent naming conflicts.
- *
- * The output SQL for the above would look something like:
- *
- * ```sql
- * SELECT *
- * FROM pages
- * WHERE
- *   pages.id in (
- *     SELECT articles.page_id AS page_id
- *     FROM articles
- *     LEFT JOIN authors AS xviqp ON articles.author = xviqp.id
- *     WHERE xviqp.name = 'Rijk'
- *   )
- * ```
- */
+function getRelationInfo(relations, collection, field) {
+    var _a, _b;
+    const implicitRelation = (_a = field.match(/^\$FOLLOW\((.*?),(.*?)(?:,(.*?))?\)$/)) === null || _a === void 0 ? void 0 : _a.slice(1);
+    if (implicitRelation) {
+        if (implicitRelation[2] === undefined) {
+            const [m2oCollection, m2oField] = implicitRelation;
+            const relation = {
+                collection: m2oCollection,
+                field: m2oField,
+                related_collection: collection,
+                schema: null,
+                meta: null,
+            };
+            return { relation, relationType: 'o2m' };
+        }
+        else {
+            const [a2oCollection, a2oItemField, a2oCollectionField] = implicitRelation;
+            const relation = {
+                collection: a2oCollection,
+                field: a2oItemField,
+                related_collection: collection,
+                schema: null,
+                meta: {
+                    one_collection_field: a2oCollectionField,
+                    one_field: field,
+                },
+            };
+            return { relation, relationType: 'o2a' };
+        }
+    }
+    const relation = (_b = relations.find((relation) => {
+        var _a;
+        return ((relation.collection === collection && relation.field === field) ||
+            (relation.related_collection === collection && ((_a = relation.meta) === null || _a === void 0 ? void 0 : _a.one_field) === field));
+    })) !== null && _b !== void 0 ? _b : null;
+    const relationType = relation ? (0, get_relation_type_1.getRelationType)({ relation, collection, field }) : null;
+    return { relation, relationType };
+}
 function applyFilter(knex, schema, rootQuery, rootFilter, collection, subQuery = false) {
     const helpers = (0, helpers_1.getHelpers)(knex);
     const relations = schema.relations;
@@ -143,31 +143,34 @@ function applyFilter(knex, schema, rootQuery, rootFilter, collection, subQuery =
             followRelation(path);
             function followRelation(pathParts, parentCollection = collection, parentAlias) {
                 /**
-                 * For M2A fields, the path can contain an optional collection scope <field>:<scope>
+                 * For A2M fields, the path can contain an optional collection scope <field>:<scope>
                  */
                 const pathRoot = pathParts[0].split(':')[0];
-                const relation = relations.find((relation) => {
-                    var _a;
-                    return ((relation.collection === parentCollection && relation.field === pathRoot) ||
-                        (relation.related_collection === parentCollection && ((_a = relation.meta) === null || _a === void 0 ? void 0 : _a.one_field) === pathRoot));
-                });
-                if (!relation)
+                const { relation, relationType } = getRelationInfo(relations, parentCollection, pathRoot);
+                if (!relation) {
                     return;
-                const relationType = (0, get_relation_type_1.getRelationType)({ relation, collection: parentCollection, field: pathRoot });
+                }
                 const alias = generateAlias();
                 (0, lodash_1.set)(aliasMap, parentAlias ? [parentAlias, ...pathParts] : pathParts, alias);
                 if (relationType === 'm2o') {
                     dbQuery.leftJoin({ [alias]: relation.related_collection }, `${parentAlias || parentCollection}.${relation.field}`, `${alias}.${schema.collections[relation.related_collection].primary}`);
                 }
-                if (relationType === 'm2a') {
+                if (relationType === 'a2o') {
                     const pathScope = pathParts[0].split(':')[1];
                     if (!pathScope) {
                         throw new exceptions_1.InvalidQueryException(`You have to provide a collection scope when filtering on a many-to-any item`);
                     }
                     dbQuery.leftJoin({ [alias]: pathScope }, (joinClause) => {
                         joinClause
-                            .on(`${parentAlias || parentCollection}.${relation.field}`, '=', knex.raw(`CAST(?? AS CHAR(255))`, `${alias}.${schema.collections[pathScope].primary}`))
-                            .andOnVal(relation.meta.one_collection_field, '=', pathScope);
+                            .onVal(relation.meta.one_collection_field, '=', pathScope)
+                            .andOn(`${parentAlias || parentCollection}.${relation.field}`, '=', knex.raw(`CAST(?? AS CHAR(255))`, `${alias}.${schema.collections[pathScope].primary}`));
+                    });
+                }
+                if (relationType === 'o2a') {
+                    dbQuery.leftJoin({ [alias]: relation.collection }, (joinClause) => {
+                        joinClause
+                            .onVal(relation.meta.one_collection_field, '=', parentCollection)
+                            .andOn(`${alias}.${relation.field}`, '=', knex.raw(`CAST(?? AS CHAR(255))`, `${parentAlias || parentCollection}.${schema.collections[parentCollection].primary}`));
                     });
                 }
                 // Still join o2m relations when in subquery OR when the o2m relation is not at the root level
@@ -179,7 +182,7 @@ function applyFilter(knex, schema, rootQuery, rootFilter, collection, subQuery =
                     if (relationType === 'm2o') {
                         parent = relation.related_collection;
                     }
-                    else if (relationType === 'm2a') {
+                    else if (relationType === 'a2o') {
                         const pathScope = pathParts[0].split(':')[1];
                         if (!pathScope) {
                             throw new exceptions_1.InvalidQueryException(`You have to provide a collection scope when filtering on a many-to-any item`);
@@ -215,17 +218,12 @@ function applyFilter(knex, schema, rootQuery, rootFilter, collection, subQuery =
             }
             const filterPath = getFilterPath(key, value);
             /**
-             * For M2A fields, the path can contain an optional collection scope <field>:<scope>
+             * For A2M fields, the path can contain an optional collection scope <field>:<scope>
              */
             const pathRoot = filterPath[0].split(':')[0];
-            const relation = relations.find((relation) => {
-                var _a;
-                return ((relation.collection === collection && relation.field === pathRoot) ||
-                    (relation.related_collection === collection && ((_a = relation.meta) === null || _a === void 0 ? void 0 : _a.one_field) === pathRoot));
-            });
+            const { relation, relationType } = getRelationInfo(relations, collection, pathRoot);
             const { operator: filterOperator, value: filterValue } = getOperation(key, value);
-            const relationType = relation ? (0, get_relation_type_1.getRelationType)({ relation, collection: collection, field: pathRoot }) : null;
-            if (relationType === 'm2o' || relationType === 'm2a' || relationType === null) {
+            if (relationType === 'm2o' || relationType === 'a2o' || relationType === null) {
                 if (filterPath.length > 1) {
                     const columnName = getWhereColumn(filterPath, collection);
                     if (!columnName)
@@ -237,7 +235,13 @@ function applyFilter(knex, schema, rootQuery, rootFilter, collection, subQuery =
                 }
             }
             else if (subQuery === false) {
-                const pkField = `${collection}.${schema.collections[relation.related_collection].primary}`;
+                if (!relation)
+                    continue;
+                let pkField = `${collection}.${schema.collections[relation.related_collection].primary}`;
+                if (relationType === 'o2a') {
+                    pkField = knex.raw(`CAST(?? AS CHAR(255))`, [pkField]);
+                }
+                // Note: knex's types don't appreciate knex.raw in whereIn, even though it's officially supported
                 dbQuery[logical].whereIn(pkField, (subQueryKnex) => {
                     const field = relation.field;
                     const collection = relation.collection;
@@ -376,22 +380,17 @@ function applyFilter(knex, schema, rootQuery, rootFilter, collection, subQuery =
             return followRelation(path);
             function followRelation(pathParts, parentCollection = collection, parentAlias) {
                 /**
-                 * For M2A fields, the path can contain an optional collection scope <field>:<scope>
+                 * For A2M fields, the path can contain an optional collection scope <field>:<scope>
                  */
                 const pathRoot = pathParts[0].split(':')[0];
-                const relation = relations.find((relation) => {
-                    var _a;
-                    return ((relation.collection === parentCollection && relation.field === pathRoot) ||
-                        (relation.related_collection === parentCollection && ((_a = relation.meta) === null || _a === void 0 ? void 0 : _a.one_field) === pathRoot));
-                });
+                const { relation, relationType } = getRelationInfo(relations, parentCollection, pathRoot);
                 if (!relation) {
                     throw new exceptions_1.InvalidQueryException(`"${parentCollection}.${pathRoot}" is not a relational field`);
                 }
-                const relationType = (0, get_relation_type_1.getRelationType)({ relation, collection: parentCollection, field: pathRoot });
                 const alias = (0, lodash_1.get)(aliasMap, parentAlias ? [parentAlias, ...pathParts] : pathParts);
                 const remainingParts = pathParts.slice(1);
                 let parent;
-                if (relationType === 'm2a') {
+                if (relationType === 'a2o') {
                     const pathScope = pathParts[0].split(':')[1];
                     if (!pathScope) {
                         throw new exceptions_1.InvalidQueryException(`You have to provide a collection scope when filtering on a many-to-any item`);

package/dist/utils/apply-snapshot.js

@@ -10,6 +10,7 @@ const database_1 = __importDefault(require("../database"));
 const get_schema_1 = require("./get-schema");
 const services_1 = require("../services");
 const lodash_1 = require("lodash");
+const logger_1 = __importDefault(require("../logger"));
 async function applySnapshot(snapshot, options) {
     var _a, _b, _c, _d;
     const database = (_a = options === null || options === void 0 ? void 0 : options.database) !== null && _a !== void 0 ? _a : (0, database_1.default)();
@@ -20,7 +21,13 @@ async function applySnapshot(snapshot, options) {
         const collectionsService = new services_1.CollectionsService({ knex: trx, schema });
         for (const { collection, diff } of snapshotDiff.collections) {
             if ((diff === null || diff === void 0 ? void 0 : diff[0].kind) === 'D') {
-                await collectionsService.deleteOne(collection);
+                try {
+                    await collectionsService.deleteOne(collection);
+                }
+                catch (err) {
+                    logger_1.default.error(`Failed to delete collection "${collection}"`);
+                    throw err;
+                }
             }
             if ((diff === null || diff === void 0 ? void 0 : diff[0].kind) === 'N' && diff[0].rhs) {
                 // We'll nest the to-be-created fields in the same collection creation, to prevent
@@ -28,10 +35,16 @@ async function applySnapshot(snapshot, options) {
                 const fields = snapshotDiff.fields
                     .filter((fieldDiff) => fieldDiff.collection === collection)
                     .map((fieldDiff) => fieldDiff.diff[0].rhs);
-                await collectionsService.createOne({
-                    ...diff[0].rhs,
-                    fields,
-                });
+                try {
+                    await collectionsService.createOne({
+                        ...diff[0].rhs,
+                        fields,
+                    });
+                }
+                catch (err) {
+                    logger_1.default.error(`Failed to create collection "${collection}"`);
+                    throw err;
+                }
                 // Now that the fields are in for this collection, we can strip them from the field
                 // edits
                 snapshotDiff.fields = snapshotDiff.fields.filter((fieldDiff) => fieldDiff.collection !== collection);
@@ -41,27 +54,51 @@ async function applySnapshot(snapshot, options) {
                     return field.collection === collection;
                 });
                 if (newValues) {
-                    await collectionsService.updateOne(collection, newValues);
+                    try {
+                        await collectionsService.updateOne(collection, newValues);
+                    }
+                    catch (err) {
+                        logger_1.default.error(`Failed to update collection "${collection}"`);
+                        throw err;
+                    }
                 }
             }
         }
         const fieldsService = new services_1.FieldsService({ knex: trx, schema: await (0, get_schema_1.getSchema)({ database: trx }) });
         for (const { collection, field, diff } of snapshotDiff.fields) {
             if ((diff === null || diff === void 0 ? void 0 : diff[0].kind) === 'N') {
-                await fieldsService.createField(collection, diff[0].rhs);
+                try {
+                    await fieldsService.createField(collection, diff[0].rhs);
+                }
+                catch (err) {
+                    logger_1.default.error(`Failed to create field "${collection}.${field}"`);
+                    throw err;
+                }
             }
             if ((diff === null || diff === void 0 ? void 0 : diff[0].kind) === 'E' || (diff === null || diff === void 0 ? void 0 : diff[0].kind) === 'A') {
                 const newValues = snapshot.fields.find((snapshotField) => {
                     return snapshotField.collection === collection && snapshotField.field === field;
                 });
                 if (newValues) {
-                    await fieldsService.updateField(collection, {
-                        ...newValues,
-                    });
+                    try {
+                        await fieldsService.updateField(collection, {
+                            ...newValues,
+                        });
+                    }
+                    catch (err) {
+                        logger_1.default.error(`Failed to update field "${collection}.${field}"`);
+                        throw err;
+                    }
                 }
             }
             if ((diff === null || diff === void 0 ? void 0 : diff[0].kind) === 'D') {
-                await fieldsService.deleteField(collection, field);
+                try {
+                    await fieldsService.deleteField(collection, field);
+                }
+                catch (err) {
+                    logger_1.default.error(`Failed to delete field "${collection}.${field}"`);
+                    throw err;
+                }
                 // Field deletion also cleans up the relationship. We should ignore any relationship
                 // changes attached to this now non-existing field
                 snapshotDiff.relations = snapshotDiff.relations.filter((relation) => (relation.collection === collection && relation.field === field) === false);
@@ -74,18 +111,36 @@ async function applySnapshot(snapshot, options) {
                 (0, lodash_1.set)(structure, diffEdit.path, undefined);
             }
             if ((diff === null || diff === void 0 ? void 0 : diff[0].kind) === 'N') {
-                await relationsService.createOne(diff[0].rhs);
+                try {
+                    await relationsService.createOne(diff[0].rhs);
+                }
+                catch (err) {
+                    logger_1.default.error(`Failed to create relation "${collection}.${field}"`);
+                    throw err;
+                }
             }
             if ((diff === null || diff === void 0 ? void 0 : diff[0].kind) === 'E' || (diff === null || diff === void 0 ? void 0 : diff[0].kind) === 'A') {
                 const newValues = snapshot.relations.find((relation) => {
                     return relation.collection === collection && relation.field === field;
                 });
                 if (newValues) {
-                    await relationsService.updateOne(collection, field, newValues);
+                    try {
+                        await relationsService.updateOne(collection, field, newValues);
+                    }
+                    catch (err) {
+                        logger_1.default.error(`Failed to update relation "${collection}.${field}"`);
+                        throw err;
+                    }
                 }
             }
             if ((diff === null || diff === void 0 ? void 0 : diff[0].kind) === 'D') {
-                await relationsService.deleteOne(collection, field);
+                try {
+                    await relationsService.deleteOne(collection, field);
+                }
+                catch (err) {
+                    logger_1.default.error(`Failed to delete relation "${collection}.${field}"`);
+                    throw err;
+                }
             }
         }
     });

package/dist/utils/get-ast-from-query.js

@@ -88,7 +88,7 @@ async function getASTFromQuery(collection, query, schema, options) {
                 const parts = name.split('.');
                 let rootField = parts[0];
                 let collectionScope = null;
-                // m2a related collection scoped field selector `fields=sections.section_id:headings.title`
+                // a2o related collection scoped field selector `fields=sections.section_id:headings.title`
                 if (rootField.includes(':')) {
                     const [key, scope] = rootField.split(':');
                     rootField = key;
@@ -136,14 +136,14 @@ async function getASTFromQuery(collection, query, schema, options) {
             if (!relationType)
                 continue;
             let child = null;
-            if (relationType === 'm2a') {
+            if (relationType === 'a2o') {
                 const allowedCollections = relation.meta.one_allowed_collections.filter((collection) => {
                     if (!permissions)
                         return true;
                     return permissions.some((permission) => permission.collection === collection);
                 });
                 child = {
-                    type: 'm2a',
+                    type: 'a2o',
                     names: allowedCollections,
                     children: {},
                     query: {},

package/dist/utils/get-default-value.js

@@ -16,12 +16,14 @@ function getDefaultValue(column) {
         return null;
     if (defaultValue === 'NULL')
         return null;
-    // Check if the default is wrapped in an extra pair of quotes, this happens in SQLite
+    // Check if the default is wrapped in an extra pair of quotes, this happens in SQLite / MariaDB
     if (typeof defaultValue === 'string' &&
         ((defaultValue.startsWith(`'`) && defaultValue.endsWith(`'`)) ||
             (defaultValue.startsWith(`"`) && defaultValue.endsWith(`"`)))) {
         defaultValue = defaultValue.slice(1, -1);
     }
+    if (defaultValue === '0000-00-00 00:00:00')
+        return null;
     switch (type) {
         case 'bigInteger':
         case 'integer':

package/dist/utils/get-permissions.d.ts

@@ -1,3 +1,3 @@
-import { Accountability } from '@directus/shared/types';
+import { Permission, Accountability } from '@directus/shared/types';
 import { SchemaOverview } from '../types';
-export declare function getPermissions(accountability: Accountability, schema: SchemaOverview): Promise<any>;
+export declare function getPermissions(accountability: Accountability, schema: SchemaOverview): Promise<Permission[]>;