directus 9.14.0 → 9.14.3

package/dist/services/graphql/index.js

@@ -12,6 +12,7 @@ const lodash_1 = require("lodash");
 const ms_1 = __importDefault(require("ms"));
 const cache_1 = require("../../cache");
 const constants_1 = require("../../constants");
+const constants_2 = require("@directus/shared/constants");
 const database_1 = __importDefault(require("../../database"));
 const env_1 = __importDefault(require("../../env"));
 const exceptions_1 = require("../../exceptions");
@@ -488,6 +489,12 @@ class GraphQLService {
                     _nnull: {
                         type: graphql_1.GraphQLBoolean,
                     },
+                    _between: {
+                        type: new graphql_1.GraphQLList(string_or_float_1.GraphQLStringOrFloat),
+                    },
+                    _nbetween: {
+                        type: new graphql_1.GraphQLList(string_or_float_1.GraphQLStringOrFloat),
+                    },
                 },
             });
             // Uses StringOrFloat rather than Float to support api dynamic variables (like `$NOW`)
@@ -524,6 +531,12 @@ class GraphQLService {
                     _nnull: {
                         type: graphql_1.GraphQLBoolean,
                     },
+                    _between: {
+                        type: new graphql_1.GraphQLList(string_or_float_1.GraphQLStringOrFloat),
+                    },
+                    _nbetween: {
+                        type: new graphql_1.GraphQLList(string_or_float_1.GraphQLStringOrFloat),
+                    },
                 },
             });
             const GeometryFilterOperators = schemaComposer.createInputTC({
@@ -671,6 +684,16 @@ class GraphQLService {
                         return acc;
                     }, {}),
                 });
+                const countType = 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;
+                    }, {}),
+                });
                 AggregateMethods[collection.collection] = {
                     group: {
                         name: 'group',
@@ -682,16 +705,11 @@ class GraphQLService {
                     },
                     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;
-                            }, {}),
-                        }),
+                        type: countType,
+                    },
+                    countDistinct: {
+                        name: 'countDistinct',
+                        type: countType,
                     },
                 };
                 const hasNumericAggregates = Object.values(collection.fields).some((field) => {
@@ -711,10 +729,6 @@ class GraphQLService {
                             name: 'sum',
                             type: AggregatedFields[collection.collection],
                         },
-                        countDistinct: {
-                            name: 'countDistinct',
-                            type: AggregatedFields[collection.collection],
-                        },
                         avgDistinct: {
                             name: 'avgDistinct',
                             type: AggregatedFields[collection.collection],
@@ -1042,6 +1056,17 @@ class GraphQLService {
             };
             query.limit = 1;
         }
+        // Transform count(a.b.c) into a.b.count(c)
+        for (let fieldIndex = 0; fieldIndex < query.fields.length; fieldIndex++) {
+            if (query.fields[fieldIndex].includes('(') && query.fields[fieldIndex].includes(')')) {
+                const functionName = query.fields[fieldIndex].split('(')[0];
+                const columnNames = query.fields[fieldIndex].match(constants_2.REGEX_BETWEEN_PARENS)[1].split('.');
+                if (columnNames.length > 1) {
+                    const column = columnNames.pop();
+                    query.fields[fieldIndex] = columnNames.join('.') + '.' + functionName + '(' + column + ')';
+                }
+            }
+        }
         const result = await this.read(collection, query);
         if (args.id) {
             return (result === null || result === void 0 ? void 0 : result[0]) || null;
@@ -1288,7 +1313,7 @@ class GraphQLService {
                         result[currentKey] = Object.values(value)[0];
                     }
                     else {
-                        result[currentKey] = (0, lodash_1.isObject)(value) ? replaceFuncDeep(value) : value;
+                        result[currentKey] = (value === null || value === void 0 ? void 0 : value.constructor) === Object ? replaceFuncDeep(value) : value;
                     }
                 });
             }

package/dist/services/server.js

@@ -51,7 +51,7 @@ class ServerService {
         this.settingsService = new settings_1.SettingsService({ knex: this.knex, schema: this.schema });
     }
     async serverInfo() {
-        var _a;
+        var _a, _b;
         const info = {};
         const projectInfo = await this.settingsService.readSingleton({
             fields: [
@@ -67,7 +67,18 @@ class ServerService {
             ],
         });
         info.project = projectInfo;
-        if (((_a = this.accountability) === null || _a === void 0 ? void 0 : _a.admin) === true) {
+        if ((_a = this.accountability) === null || _a === void 0 ? void 0 : _a.user) {
+            if (env_1.default.RATE_LIMITER_ENABLED) {
+                info.rateLimit = {
+                    points: env_1.default.RATE_LIMITER_POINTS,
+                    duration: env_1.default.RATE_LIMITER_DURATION,
+                };
+            }
+            else {
+                info.rateLimit = false;
+            }
+        }
+        if (((_b = this.accountability) === null || _b === void 0 ? void 0 : _b.admin) === true) {
             const osType = os_1.default.type() === 'Darwin' ? 'macOS' : os_1.default.type();
             const osVersion = osType === 'macOS' ? `${(0, macos_release_1.default)().name} (${(0, macos_release_1.default)().version})` : os_1.default.release();
             info.directus = {

package/dist/types/ast.d.ts

@@ -2,7 +2,7 @@ import { Query, Relation } from '@directus/shared/types';
 export declare type M2ONode = {
     type: 'm2o';
     name: string;
-    children: (NestedCollectionNode | FieldNode)[];
+    children: (NestedCollectionNode | FieldNode | FunctionFieldNode)[];
     query: Query;
     fieldKey: string;
     relation: Relation;
@@ -13,7 +13,7 @@ export declare type A2MNode = {
     type: 'a2o';
     names: string[];
     children: {
-        [collection: string]: (NestedCollectionNode | FieldNode)[];
+        [collection: string]: (NestedCollectionNode | FieldNode | FunctionFieldNode)[];
     };
     query: {
         [collection: string]: Query;
@@ -28,7 +28,7 @@ export declare type A2MNode = {
 export declare type O2MNode = {
     type: 'o2m';
     name: string;
-    children: (NestedCollectionNode | FieldNode)[];
+    children: (NestedCollectionNode | FieldNode | FunctionFieldNode)[];
     query: Query;
     fieldKey: string;
     relation: Relation;
@@ -41,9 +41,16 @@ export declare type FieldNode = {
     name: string;
     fieldKey: string;
 };
+export declare type FunctionFieldNode = {
+    type: 'functionField';
+    name: string;
+    fieldKey: string;
+    query: Query;
+    relatedCollection: string;
+};
 export declare type AST = {
     type: 'root';
     name: string;
-    children: (NestedCollectionNode | FieldNode)[];
+    children: (NestedCollectionNode | FieldNode | FunctionFieldNode)[];
     query: Query;
 };

package/dist/utils/apply-query.js

@@ -129,8 +129,8 @@ function applySort(knex, schema, rootQuery, rootSort, collection, subQuery = fal
                 relations,
                 knex,
             });
-            const colPath = (0, get_column_path_1.getColumnPath)({ path: column, collection, aliasMap, relations }) || '';
-            const [alias, field] = colPath.split('.');
+            const { columnPath } = (0, get_column_path_1.getColumnPath)({ path: column, collection, aliasMap, relations });
+            const [alias, field] = columnPath.split('.');
             return {
                 order,
                 column: (0, get_column_1.getColumn)(knex, alias, field, false, schema),
@@ -208,18 +208,10 @@ function applyFilter(knex, schema, rootQuery, rootFilter, collection, subQuery =
             const { operator: filterOperator, value: filterValue } = getOperation(key, value);
             if (relationType === 'm2o' || relationType === 'a2o' || relationType === null) {
                 if (filterPath.length > 1) {
-                    const columnName = (0, get_column_path_1.getColumnPath)({ path: filterPath, collection, relations, aliasMap });
-                    if (!columnName)
+                    const { columnPath, targetCollection } = (0, get_column_path_1.getColumnPath)({ path: filterPath, collection, relations, aliasMap });
+                    if (!columnPath)
                         continue;
-                    if (relation === null || relation === void 0 ? void 0 : relation.related_collection) {
-                        applyFilterToQuery(columnName, filterOperator, filterValue, logical, relation.related_collection); // m2o
-                    }
-                    else if (filterPath[0].includes(':')) {
-                        applyFilterToQuery(columnName, filterOperator, filterValue, logical, filterPath[0].split(':')[1]); // a2o
-                    }
-                    else {
-                        applyFilterToQuery(columnName, filterOperator, filterValue, logical);
-                    }
+                    applyFilterToQuery(columnPath, filterOperator, filterValue, logical, targetCollection);
                 }
                 else {
                     applyFilterToQuery(`${collection}.${filterPath[0]}`, filterOperator, filterValue, logical);

package/dist/utils/apply-snapshot.js

@@ -32,23 +32,18 @@ async function applySnapshot(snapshot, options) {
                         .filter((fieldDiff) => fieldDiff.collection === collection)
                         .map((fieldDiff) => fieldDiff.diff[0].rhs)
                         .map((fieldDiff) => {
-                        // Casts field type to UUID when applying SQLite-based schema on other databases.
-                        // This is needed because SQLite snapshots UUID fields as char with length 36, and
-                        // it will fail when trying to create relation between char field to UUID field
-                        if (!fieldDiff.schema ||
-                            fieldDiff.schema.data_type !== 'char' ||
-                            fieldDiff.schema.max_length !== 36 ||
-                            !fieldDiff.schema.foreign_key_table ||
-                            !fieldDiff.schema.foreign_key_column) {
-                            return fieldDiff;
+                        var _a, _b, _c, _d, _e;
+                        // Casts field type to UUID when applying non-PostgreSQL schema onto PostgreSQL database.
+                        // This is needed because they snapshots UUID fields as char with length 36.
+                        if (((_a = fieldDiff.schema) === null || _a === void 0 ? void 0 : _a.data_type) === 'char' &&
+                            ((_b = fieldDiff.schema) === null || _b === void 0 ? void 0 : _b.max_length) === 36 &&
+                            (((_c = fieldDiff.schema) === null || _c === void 0 ? void 0 : _c.is_primary_key) ||
+                                (((_d = fieldDiff.schema) === null || _d === void 0 ? void 0 : _d.foreign_key_table) && ((_e = fieldDiff.schema) === null || _e === void 0 ? void 0 : _e.foreign_key_column)))) {
+                            return (0, lodash_1.merge)(fieldDiff, { type: 'uuid', schema: { data_type: 'uuid', max_length: null } });
                         }
-                        const matchingForeignKeyTable = schema.collections[fieldDiff.schema.foreign_key_table];
-                        if (!matchingForeignKeyTable)
-                            return fieldDiff;
-                        const matchingForeignKeyField = matchingForeignKeyTable.fields[fieldDiff.schema.foreign_key_column];
-                        if (!matchingForeignKeyField || matchingForeignKeyField.type !== 'uuid')
+                        else {
                             return fieldDiff;
-                        return (0, lodash_1.merge)(fieldDiff, { type: 'uuid', schema: { data_type: 'uuid', max_length: null } });
+                        }
                     });
                     try {
                         await collectionsService.createOne({
@@ -80,8 +75,37 @@ async function applySnapshot(snapshot, options) {
                 }
             }
         };
-        // create top level collections (no group) first, then continue with nested collections recursively
-        await createCollections(snapshotDiff.collections.filter(({ diff }) => { var _a; return diff[0].kind === 'N' && ((_a = diff[0].rhs.meta) === null || _a === void 0 ? void 0 : _a.group) === null; }));
+        // Finds all collections that need to be created
+        const filterCollectionsForCreation = ({ diff }) => {
+            var _a;
+            // Check new collections only
+            const isNewCollection = diff[0].kind === 'N';
+            if (!isNewCollection)
+                return false;
+            // Create now if no group
+            const groupName = (_a = diff[0].rhs.meta) === null || _a === void 0 ? void 0 : _a.group;
+            if (!groupName)
+                return true;
+            // Check if parent collection already exists in schema
+            const parentExists = current.collections.find((c) => c.collection === groupName) !== undefined;
+            // If this is a new collection and the parent collection doesn't exist in current schema ->
+            // Check if the parent collection will be created as part of applying this snapshot ->
+            // If yes -> this collection will be created recursively
+            // If not -> create now
+            // (ex.)
+            // TopLevelCollection - I exist in current schema
+            // 		NestedCollection - I exist in snapshotDiff as a new collection
+            //			TheCurrentCollectionInIteration - I exist in snapshotDiff as a new collection but will be created as part of NestedCollection
+            const parentWillBeCreatedInThisApply = snapshotDiff.collections.filter(({ collection, diff }) => diff[0].kind === 'N' && collection === groupName)
+                .length > 0;
+            // Has group, but parent is not new, parent is also not being created in this snapshot apply
+            if (parentExists && !parentWillBeCreatedInThisApply)
+                return true;
+            return false;
+        };
+        // Create top level collections (no group, or highest level in existing group) first,
+        // then continue with nested collections recursively
+        await createCollections(snapshotDiff.collections.filter(filterCollectionsForCreation));
         // delete top level collections (no group) first, then continue with nested collections recursively
         await deleteCollections(snapshotDiff.collections.filter(({ diff }) => { var _a; return diff[0].kind === 'D' && ((_a = diff[0].lhs.meta) === null || _a === void 0 ? void 0 : _a.group) === null; }));
         for (const { collection, diff } of snapshotDiff.collections) {

package/dist/utils/filter-items.js

@@ -1,10 +1,7 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.filterItems = void 0;
-const generate_joi_1 = __importDefault(require("./generate-joi"));
+const utils_1 = require("@directus/shared/utils");
 /*
  Note: Filtering is normally done through SQL in run-ast. This function can be used in case an already
  existing array of items has to be filtered using the same filter syntax as used in the ast-to-sql flow
@@ -16,7 +13,7 @@ function filterItems(items, filter) {
         return passesFilter(item, filter);
     });
     function passesFilter(item, filter) {
-        if (!filter)
+        if (!filter || Object.keys(filter).length === 0)
             return true;
         if (Object.keys(filter)[0] === '_and') {
             const subfilter = Object.values(filter)[0];
@@ -31,7 +28,7 @@ function filterItems(items, filter) {
             });
         }
         else {
-            const schema = (0, generate_joi_1.default)(filter);
+            const schema = (0, utils_1.generateJoi)(filter);
             const { error } = schema.validate(item);
             return error === undefined;
         }

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

@@ -5,6 +5,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const lodash_1 = require("lodash");
 const get_relation_type_1 = require("../utils/get-relation-type");
+const constants_1 = require("@directus/shared/constants");
 async function getASTFromQuery(collection, query, schema, options) {
     var _a, _b, _c, _d, _e;
     query = (0, lodash_1.cloneDeep)(query);
@@ -118,6 +119,23 @@ async function getASTFromQuery(collection, query, schema, options) {
                 }
             }
             else {
+                if (fieldKey.includes('(') && fieldKey.includes(')')) {
+                    const columnName = fieldKey.match(constants_1.REGEX_BETWEEN_PARENS)[1];
+                    const foundField = schema.collections[parentCollection].fields[columnName];
+                    if (foundField && foundField.type === 'alias') {
+                        const foundRelation = schema.relations.find((relation) => { var _a; return relation.related_collection === parentCollection && ((_a = relation.meta) === null || _a === void 0 ? void 0 : _a.one_field) === columnName; });
+                        if (foundRelation) {
+                            children.push({
+                                type: 'functionField',
+                                name,
+                                fieldKey,
+                                query: {},
+                                relatedCollection: foundRelation.collection,
+                            });
+                            continue;
+                        }
+                    }
+                }
                 children.push({ type: 'field', name, fieldKey });
             }
         }

package/dist/utils/get-column-path.d.ts

@@ -11,6 +11,10 @@ export declare type ColPathProps = {
 /**
  * Converts a Directus field list path to the correct SQL names based on the constructed alias map.
  * For example: ['author', 'role', 'name'] -> 'ljnsv.name'
+ * Also returns the target collection of the column: 'directus_roles'
  */
-export declare function getColumnPath({ path, collection, aliasMap, relations }: ColPathProps): string | void;
+export declare function getColumnPath({ path, collection, aliasMap, relations }: ColPathProps): {
+    columnPath: string;
+    targetCollection: string;
+};
 export {};

package/dist/utils/get-column-path.js

@@ -7,6 +7,7 @@ const lodash_1 = require("lodash");
 /**
  * Converts a Directus field list path to the correct SQL names based on the constructed alias map.
  * For example: ['author', 'role', 'name'] -> 'ljnsv.name'
+ * Also returns the target collection of the column: 'directus_roles'
  */
 function getColumnPath({ path, collection, aliasMap, relations }) {
     return followRelation(path);
@@ -36,11 +37,12 @@ function getColumnPath({ path, collection, aliasMap, relations }) {
             parent = relation.collection;
         }
         if (remainingParts.length === 1) {
-            return `${alias || parent}.${remainingParts[0]}`;
+            return { columnPath: `${alias || parent}.${remainingParts[0]}`, targetCollection: parent };
         }
         if (remainingParts.length) {
             return followRelation(remainingParts, parent, alias);
         }
+        return { columnPath: '', targetCollection: '' };
     }
 }
 exports.getColumnPath = getColumnPath;

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

@@ -1,4 +1,4 @@
-import { SchemaOverview } from '@directus/shared/types';
+import { Query, SchemaOverview } from '@directus/shared/types';
 import { Knex } from 'knex';
 /**
  * Return column prefixed by table. If column includes functions (like `year(date_created)`), the
@@ -10,4 +10,4 @@ import { Knex } from 'knex';
  * @param alias Whether or not to add a SQL AS statement
  * @returns Knex raw instance
  */
-export declare function getColumn(knex: Knex, table: string, column: string, alias: string | false | undefined, schema: SchemaOverview): Knex.Raw;
+export declare function getColumn(knex: Knex, table: string, column: string, alias: string | false | undefined, schema: SchemaOverview, query?: Query): Knex.Raw;

package/dist/utils/get-column.js

@@ -16,7 +16,7 @@ const apply_function_to_column_name_1 = require("./apply-function-to-column-name
  * @param alias Whether or not to add a SQL AS statement
  * @returns Knex raw instance
  */
-function getColumn(knex, table, column, alias = (0, apply_function_to_column_name_1.applyFunctionToColumnName)(column), schema) {
+function getColumn(knex, table, column, alias = (0, apply_function_to_column_name_1.applyFunctionToColumnName)(column), schema, query) {
     var _a, _b, _c, _d;
     const fn = (0, helpers_1.getFunctions)(knex, schema);
     if (column.includes('(') && column.includes(')')) {
@@ -28,7 +28,7 @@ function getColumn(knex, table, column, alias = (0, apply_function_to_column_nam
             if (allowedFunctions.includes(functionName) === false) {
                 throw new exceptions_1.InvalidQueryException(`Invalid function specified "${functionName}"`);
             }
-            const result = fn[functionName](table, columnName, { type });
+            const result = fn[functionName](table, columnName, { type, query });
             if (alias) {
                 return knex.raw(result + ' AS ??', [alias]);
             }

package/dist/utils/get-config-from-env.js

@@ -36,7 +36,7 @@ function getConfigFromEnv(prefix, omitPrefix, type = 'camelcase') {
     return config;
     function transform(key) {
         if (type === 'camelcase') {
-            return (0, camelcase_1.default)(key);
+            return (0, camelcase_1.default)(key, { locale: false });
         }
         else if (type === 'underscore') {
             return key.toLowerCase();

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

@@ -1,4 +1,3 @@
-/// <reference types="lodash" />
 import { Permission } from '@directus/shared/types';
 export declare function mergePermissions(strategy: 'and' | 'or', ...permissions: Permission[][]): Permission[];
 export declare function mergePermission(strategy: 'and' | 'or', currentPerm: Permission, newPerm: Permission): import("lodash").Omit<{