directus 9.14.5 → 9.16.0

package/dist/services/flows.js

@@ -39,12 +39,16 @@ class FlowsService extends items_1.ItemsService {
     }
     async deleteOne(key, opts) {
         const flowManager = (0, flows_1.getFlowManager)();
+        // this is to prevent foreign key constraint error on directus_operations resolve/reject during cascade deletion
+        await this.knex('directus_operations').update({ resolve: null, reject: null }).where('flow', key);
         const result = await super.deleteOne(key, opts);
         await flowManager.reload();
         return result;
     }
     async deleteMany(keys, opts) {
         const flowManager = (0, flows_1.getFlowManager)();
+        // this is to prevent foreign key constraint error on directus_operations resolve/reject during cascade deletion
+        await this.knex('directus_operations').update({ resolve: null, reject: null }).whereIn('flow', keys);
         const result = await super.deleteMany(keys, opts);
         await flowManager.reload();
         return result;

package/dist/services/graphql/index.d.ts

@@ -1,6 +1,6 @@
 import { BaseException } from '@directus/shared/exceptions';
 import { Accountability, Query, SchemaOverview } from '@directus/shared/types';
-import { ArgumentNode, FormattedExecutionResult, FragmentDefinitionNode, GraphQLError, GraphQLResolveInfo, GraphQLSchema, ObjectFieldNode, SelectionNode } from 'graphql';
+import { ArgumentNode, FormattedExecutionResult, FragmentDefinitionNode, GraphQLError, GraphQLResolveInfo, GraphQLSchema, SelectionNode } from 'graphql';
 import { ObjectTypeComposer, SchemaComposer } from 'graphql-compose';
 import { Knex } from 'knex';
 import { AbstractServiceOptions, GraphQLParams, Item } from '../../types';
@@ -44,7 +44,7 @@ export declare class GraphQLService {
      * In order to do that, we'll parse over all ArgumentNodes and ObjectFieldNodes to manually recreate an object structure
      * of arguments
      */
-    parseArgs(args: readonly ArgumentNode[] | readonly ObjectFieldNode[], variableValues: GraphQLResolveInfo['variableValues']): Record<string, any>;
+    parseArgs(args: readonly ArgumentNode[], variableValues: GraphQLResolveInfo['variableValues']): Record<string, any>;
     /**
      * Get a Directus Query object from the parsed arguments (rawQuery) and GraphQL AST selectionSet. Converts SelectionSet into
      * Directus' `fields` query for use in the resolver. Also applies variables where appropriate.

package/dist/services/graphql/index.js

@@ -50,6 +50,7 @@ const geojson_1 = require("./types/geojson");
 const string_or_float_1 = require("./types/string-or-float");
 const void_1 = require("./types/void");
 const add_path_to_validation_error_1 = require("./utils/add-path-to-validation-error");
+const hash_1 = require("./types/hash");
 const validationRules = Array.from(graphql_1.specifiedRules);
 if (env_1.default.GRAPHQL_INTROSPECTION === false) {
     validationRules.push(graphql_1.NoSchemaIntrospectionCustomRule);
@@ -273,11 +274,13 @@ class GraphQLService {
                 CollectionTypes[collection.collection] = schemaComposer.createObjectTC({
                     name: action === 'read' ? collection.collection : `${action}_${collection.collection}`,
                     fields: Object.values(collection.fields).reduce((acc, field) => {
-                        let type = (0, get_graphql_type_1.getGraphQLType)(field.type);
+                        let type = (0, get_graphql_type_1.getGraphQLType)(field.type, field.special);
                         // GraphQL doesn't differentiate between not-null and has-to-be-submitted. We
                         // can't non-null in update, as that would require every not-nullable field to be
                         // submitted on updates
-                        if (field.nullable === false && action !== 'update') {
+                        if (field.nullable === false &&
+                            !constants_1.GENERATE_SPECIAL.some((flag) => field.special.includes(flag)) &&
+                            action !== 'update') {
                             type = (0, graphql_1.GraphQLNonNull)(type);
                         }
                         if (collection.primary === field.field) {
@@ -562,6 +565,23 @@ class GraphQLService {
                     },
                 },
             });
+            const HashFilterOperators = schemaComposer.createInputTC({
+                name: 'hash_filter_operators',
+                fields: {
+                    _null: {
+                        type: graphql_1.GraphQLBoolean,
+                    },
+                    _nnull: {
+                        type: graphql_1.GraphQLBoolean,
+                    },
+                    _empty: {
+                        type: graphql_1.GraphQLBoolean,
+                    },
+                    _nempty: {
+                        type: graphql_1.GraphQLBoolean,
+                    },
+                },
+            });
             const CountFunctionFilterOperators = schemaComposer.createInputTC({
                 name: 'count_function_filter_operators',
                 fields: {
@@ -619,7 +639,7 @@ class GraphQLService {
                 ReadableCollectionFilterTypes[collection.collection] = schemaComposer.createInputTC({
                     name: `${collection.collection}_filter`,
                     fields: Object.values(collection.fields).reduce((acc, field) => {
-                        const graphqlType = (0, get_graphql_type_1.getGraphQLType)(field.type);
+                        const graphqlType = (0, get_graphql_type_1.getGraphQLType)(field.type, field.special);
                         let filterOperatorType;
                         switch (graphqlType) {
                             case graphql_1.GraphQLBoolean:
@@ -635,6 +655,9 @@ class GraphQLService {
                             case geojson_1.GraphQLGeoJSON:
                                 filterOperatorType = GeometryFilterOperators;
                                 break;
+                            case hash_1.GraphQLHash:
+                                filterOperatorType = HashFilterOperators;
+                                break;
                             default:
                                 filterOperatorType = StringFilterOperators;
                         }
@@ -669,7 +692,7 @@ class GraphQLService {
                 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);
+                        const graphqlType = (0, get_graphql_type_1.getGraphQLType)(field.type, field.special);
                         switch (graphqlType) {
                             case graphql_1.GraphQLInt:
                             case graphql_1.GraphQLFloat:
@@ -713,7 +736,7 @@ class GraphQLService {
                     },
                 };
                 const hasNumericAggregates = Object.values(collection.fields).some((field) => {
-                    const graphqlType = (0, get_graphql_type_1.getGraphQLType)(field.type);
+                    const graphqlType = (0, get_graphql_type_1.getGraphQLType)(field.type, field.special);
                     if (graphqlType === graphql_1.GraphQLInt || graphqlType === graphql_1.GraphQLFloat) {
                         return true;
                     }
@@ -1184,38 +1207,29 @@ class GraphQLService {
     parseArgs(args, variableValues) {
         if (!args || args.length === 0)
             return {};
-        const parseObjectValue = (arg) => {
-            return this.parseArgs(arg.fields, variableValues);
-        };
-        const argsObject = {};
-        for (const argument of args) {
-            if (argument.value.kind === 'ObjectValue') {
-                argsObject[argument.name.value] = parseObjectValue(argument.value);
-            }
-            else if (argument.value.kind === 'Variable') {
-                argsObject[argument.name.value] = variableValues[argument.value.name.value];
-            }
-            else if (argument.value.kind === 'ListValue') {
-                const values = [];
-                for (const valueNode of argument.value.values) {
-                    if (valueNode.kind === 'ObjectValue') {
-                        values.push(this.parseArgs(valueNode.fields, variableValues));
-                    }
-                    else {
-                        if (valueNode.kind === 'Variable') {
-                            values.push(variableValues[valueNode.name.value]);
-                        }
-                        else {
-                            values.push(valueNode.value);
-                        }
-                    }
-                }
-                argsObject[argument.name.value] = values;
+        const parse = (node) => {
+            switch (node.kind) {
+                case 'Variable':
+                    return variableValues[node.name.value];
+                case 'ListValue':
+                    return node.values.map(parse);
+                case 'ObjectValue':
+                    return Object.fromEntries(node.fields.map((node) => [node.name.value, parse(node.value)]));
+                case 'NullValue':
+                    return null;
+                case 'StringValue':
+                    return String(node.value);
+                case 'IntValue':
+                case 'FloatValue':
+                    return Number(node.value);
+                case 'BooleanValue':
+                    return Boolean(node.value);
+                case 'EnumValue':
+                default:
+                    return node.value;
             }
-            else {
-                argsObject[argument.name.value] = argument.value.value;
-            }
-        }
+        };
+        const argsObject = Object.fromEntries(args.map((arg) => [arg.name.value, parse(arg.value)]));
         return argsObject;
     }
     /**
@@ -1315,7 +1329,8 @@ class GraphQLService {
                         result[currentKey] = Object.values(value)[0];
                     }
                     else {
-                        result[currentKey] = (value === null || value === void 0 ? void 0 : value.constructor) === Object ? replaceFuncDeep(value) : value;
+                        result[currentKey] =
+                            (value === null || value === void 0 ? void 0 : value.constructor) === Object || (value === null || value === void 0 ? void 0 : value.constructor) === Array ? replaceFuncDeep(value) : value;
                     }
                 });
             }
@@ -1878,7 +1893,9 @@ class GraphQLService {
                     name: 'directus_collections_meta',
                     fields: Object.values(schema.read.collections['directus_collections'].fields).reduce((acc, field) => {
                         acc[field.field] = {
-                            type: field.nullable ? (0, get_graphql_type_1.getGraphQLType)(field.type) : (0, graphql_1.GraphQLNonNull)((0, get_graphql_type_1.getGraphQLType)(field.type)),
+                            type: field.nullable
+                                ? (0, get_graphql_type_1.getGraphQLType)(field.type, field.special)
+                                : (0, graphql_1.GraphQLNonNull)((0, get_graphql_type_1.getGraphQLType)(field.type, field.special)),
                             description: field.note,
                         };
                         return acc;
@@ -1927,7 +1944,9 @@ class GraphQLService {
                     name: 'directus_fields_meta',
                     fields: Object.values(schema.read.collections['directus_fields'].fields).reduce((acc, field) => {
                         acc[field.field] = {
-                            type: field.nullable ? (0, get_graphql_type_1.getGraphQLType)(field.type) : (0, graphql_1.GraphQLNonNull)((0, get_graphql_type_1.getGraphQLType)(field.type)),
+                            type: field.nullable
+                                ? (0, get_graphql_type_1.getGraphQLType)(field.type, field.special)
+                                : (0, graphql_1.GraphQLNonNull)((0, get_graphql_type_1.getGraphQLType)(field.type, field.special)),
                             description: field.note,
                         };
                         return acc;
@@ -2014,7 +2033,7 @@ class GraphQLService {
                     name: 'directus_relations_meta',
                     fields: Object.values(schema.read.collections['directus_relations'].fields).reduce((acc, field) => {
                         acc[field.field] = {
-                            type: (0, get_graphql_type_1.getGraphQLType)(field.type),
+                            type: (0, get_graphql_type_1.getGraphQLType)(field.type, field.special),
                             description: field.note,
                         };
                         return acc;

package/dist/services/graphql/types/hash.d.ts

@@ -0,0 +1,2 @@
+import { GraphQLScalarType } from 'graphql';
+export declare const GraphQLHash: GraphQLScalarType;

package/dist/services/graphql/types/hash.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphQLHash = void 0;
+const graphql_1 = require("graphql");
+exports.GraphQLHash = new graphql_1.GraphQLScalarType({
+    ...graphql_1.GraphQLString,
+    name: 'Hash',
+    description: 'Hashed string values',
+});

package/dist/services/items.js

@@ -52,6 +52,7 @@ class ItemsService {
             .filter((field) => field.alias === true)
             .map((field) => field.field);
         const payload = (0, lodash_1.cloneDeep)(data);
+        const nestedActionEvents = [];
         // By wrapping the logic in a transaction, we make sure we automatically roll back all the
         // changes in the DB if any of the parts contained within throws an error. This also means
         // that any errors thrown in any nested relational changes will bubble up and cancel the whole
@@ -84,8 +85,8 @@ class ItemsService {
             const payloadWithPresets = this.accountability
                 ? await authorizationService.validatePayload('create', this.collection, payloadAfterHooks)
                 : payloadAfterHooks;
-            const { payload: payloadWithM2O, revisions: revisionsM2O } = await payloadService.processM2O(payloadWithPresets);
-            const { payload: payloadWithA2O, revisions: revisionsA2O } = await payloadService.processA2O(payloadWithM2O);
+            const { payload: payloadWithM2O, revisions: revisionsM2O, nestedActionEvents: nestedActionEventsM2O, } = await payloadService.processM2O(payloadWithPresets, opts);
+            const { payload: payloadWithA2O, revisions: revisionsA2O, nestedActionEvents: nestedActionEventsA2O, } = await payloadService.processA2O(payloadWithM2O, opts);
             const payloadWithoutAliases = (0, lodash_1.pick)(payloadWithA2O, (0, lodash_1.without)(fields, ...aliases));
             const payloadWithTypeCasting = await payloadService.processValues('create', payloadWithoutAliases);
             // In case of manual string / UUID primary keys, the PK already exists in the object we're saving.
@@ -113,7 +114,10 @@ class ItemsService {
                 // to read from it
                 payload[primaryKeyField] = primaryKey;
             }
-            const { revisions: revisionsO2M } = await payloadService.processO2M(payload, primaryKey);
+            const { revisions: revisionsO2M, nestedActionEvents: nestedActionEventsO2M } = await payloadService.processO2M(payload, primaryKey, opts);
+            nestedActionEvents.push(...nestedActionEventsM2O);
+            nestedActionEvents.push(...nestedActionEventsA2O);
+            nestedActionEvents.push(...nestedActionEventsO2M);
             // If this is an authenticated action, and accountability tracking is enabled, save activity row
             if (this.accountability && this.schema.collections[this.collection].accountability !== null) {
                 const activityService = new index_1.ActivityService({
@@ -154,17 +158,30 @@ class ItemsService {
             return primaryKey;
         });
         if ((opts === null || opts === void 0 ? void 0 : opts.emitEvents) !== false) {
-            emitter_1.default.emitAction(this.eventScope === 'items' ? ['items.create', `${this.collection}.items.create`] : `${this.eventScope}.create`, {
-                payload,
-                key: primaryKey,
-                collection: this.collection,
-            }, {
-                // This hook is called async. If we would pass the transaction here, the hook can be
-                // called after the transaction is done #5460
-                database: this.knex || (0, database_1.default)(),
-                schema: this.schema,
-                accountability: this.accountability,
-            });
+            const actionEvent = {
+                event: this.eventScope === 'items'
+                    ? ['items.create', `${this.collection}.items.create`]
+                    : `${this.eventScope}.create`,
+                meta: {
+                    payload,
+                    key: primaryKey,
+                    collection: this.collection,
+                },
+                context: {
+                    database: (0, database_1.default)(),
+                    schema: this.schema,
+                    accountability: this.accountability,
+                },
+            };
+            if (!(opts === null || opts === void 0 ? void 0 : opts.bypassEmitAction)) {
+                emitter_1.default.emitAction(actionEvent.event, actionEvent.meta, actionEvent.context);
+            }
+            else {
+                opts.bypassEmitAction(actionEvent);
+            }
+            for (const nestedActionEvent of nestedActionEvents) {
+                emitter_1.default.emitAction(nestedActionEvent.event, nestedActionEvent.meta, nestedActionEvent.context);
+            }
         }
         if (this.cache && env_1.default.CACHE_AUTO_PURGE && (opts === null || opts === void 0 ? void 0 : opts.autoPurgeCache) !== false) {
             await this.cache.clear();
@@ -323,6 +340,7 @@ class ItemsService {
             .filter((field) => field.alias === true)
             .map((field) => field.field);
         const payload = (0, lodash_1.cloneDeep)(data);
+        const nestedActionEvents = [];
         const authorizationService = new authorization_1.AuthorizationService({
             accountability: this.accountability,
             knex: this.knex,
@@ -356,8 +374,8 @@ class ItemsService {
                 knex: trx,
                 schema: this.schema,
             });
-            const { payload: payloadWithM2O, revisions: revisionsM2O } = await payloadService.processM2O(payloadWithPresets);
-            const { payload: payloadWithA2O, revisions: revisionsA2O } = await payloadService.processA2O(payloadWithM2O);
+            const { payload: payloadWithM2O, revisions: revisionsM2O, nestedActionEvents: nestedActionEventsM2O, } = await payloadService.processM2O(payloadWithPresets, opts);
+            const { payload: payloadWithA2O, revisions: revisionsA2O, nestedActionEvents: nestedActionEventsA2O, } = await payloadService.processA2O(payloadWithM2O, opts);
             const payloadWithoutAliasAndPK = (0, lodash_1.pick)(payloadWithA2O, (0, lodash_1.without)(fields, primaryKeyField, ...aliases));
             const payloadWithTypeCasting = await payloadService.processValues('update', payloadWithoutAliasAndPK);
             if (Object.keys(payloadWithTypeCasting).length > 0) {
@@ -369,9 +387,12 @@ class ItemsService {
                 }
             }
             const childrenRevisions = [...revisionsM2O, ...revisionsA2O];
+            nestedActionEvents.push(...nestedActionEventsM2O);
+            nestedActionEvents.push(...nestedActionEventsA2O);
             for (const key of keys) {
-                const { revisions } = await payloadService.processO2M(payload, key);
+                const { revisions, nestedActionEvents: nestedActionEventsO2M } = await payloadService.processO2M(payload, key, opts);
                 childrenRevisions.push(...revisions);
+                nestedActionEvents.push(...nestedActionEventsO2M);
             }
             // If this is an authenticated action, and accountability tracking is enabled, save activity row
             if (this.accountability && this.schema.collections[this.collection].accountability !== null) {
@@ -427,17 +448,30 @@ class ItemsService {
             await this.cache.clear();
         }
         if ((opts === null || opts === void 0 ? void 0 : opts.emitEvents) !== false) {
-            emitter_1.default.emitAction(this.eventScope === 'items' ? ['items.update', `${this.collection}.items.update`] : `${this.eventScope}.update`, {
-                payload,
-                keys,
-                collection: this.collection,
-            }, {
-                // This hook is called async. If we would pass the transaction here, the hook can be
-                // called after the transaction is done #5460
-                database: this.knex || (0, database_1.default)(),
-                schema: this.schema,
-                accountability: this.accountability,
-            });
+            const actionEvent = {
+                event: this.eventScope === 'items'
+                    ? ['items.update', `${this.collection}.items.update`]
+                    : `${this.eventScope}.update`,
+                meta: {
+                    payload,
+                    keys,
+                    collection: this.collection,
+                },
+                context: {
+                    database: (0, database_1.default)(),
+                    schema: this.schema,
+                    accountability: this.accountability,
+                },
+            };
+            if (!(opts === null || opts === void 0 ? void 0 : opts.bypassEmitAction)) {
+                emitter_1.default.emitAction(actionEvent.event, actionEvent.meta, actionEvent.context);
+            }
+            else {
+                opts.bypassEmitAction(actionEvent);
+            }
+            for (const nestedActionEvent of nestedActionEvents) {
+                emitter_1.default.emitAction(nestedActionEvent.event, nestedActionEvent.meta, nestedActionEvent.context);
+            }
         }
         return keys;
     }
@@ -547,17 +581,27 @@ class ItemsService {
             await this.cache.clear();
         }
         if ((opts === null || opts === void 0 ? void 0 : opts.emitEvents) !== false) {
-            emitter_1.default.emitAction(this.eventScope === 'items' ? ['items.delete', `${this.collection}.items.delete`] : `${this.eventScope}.delete`, {
-                payload: keys,
-                keys: keys,
-                collection: this.collection,
-            }, {
-                // This hook is called async. If we would pass the transaction here, the hook can be
-                // called after the transaction is done #5460
-                database: this.knex || (0, database_1.default)(),
-                schema: this.schema,
-                accountability: this.accountability,
-            });
+            const actionEvent = {
+                event: this.eventScope === 'items'
+                    ? ['items.delete', `${this.collection}.items.delete`]
+                    : `${this.eventScope}.delete`,
+                meta: {
+                    payload: keys,
+                    keys: keys,
+                    collection: this.collection,
+                },
+                context: {
+                    database: (0, database_1.default)(),
+                    schema: this.schema,
+                    accountability: this.accountability,
+                },
+            };
+            if (!(opts === null || opts === void 0 ? void 0 : opts.bypassEmitAction)) {
+                emitter_1.default.emitAction(actionEvent.event, actionEvent.meta, actionEvent.context);
+            }
+            else {
+                opts.bypassEmitAction(actionEvent);
+            }
         }
         return keys;
     }

package/dist/services/items.test.d.ts

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