directus 9.7.1 → 9.9.1

package/dist/services/fields.js

@@ -40,6 +40,7 @@ const utils_1 = require("@directus/shared/utils");
 const lodash_1 = require("lodash");
 const relations_1 = require("./relations");
 const helpers_1 = require("../database/helpers");
+const constants_2 = require("@directus/shared/constants");
 class FieldsService {
     constructor(options) {
         this.knex = options.knex || (0, database_1.default)();
@@ -60,6 +61,7 @@ class FieldsService {
         }));
     }
     async readAll(collection) {
+        var _a, _b, _c, _d;
         let fields;
         if (this.accountability && this.accountability.admin !== true && this.hasReadAccess === false) {
             throw new exceptions_1.ForbiddenException();
@@ -151,6 +153,15 @@ class FieldsService {
                 return allowedFields.includes(field.field);
             });
         }
+        // Update specific database type overrides
+        for (const field of result) {
+            if ((_b = (_a = field.meta) === null || _a === void 0 ? void 0 : _a.special) === null || _b === void 0 ? void 0 : _b.includes('cast-timestamp')) {
+                field.type = 'timestamp';
+            }
+            else if ((_d = (_c = field.meta) === null || _c === void 0 ? void 0 : _c.special) === null || _d === void 0 ? void 0 : _d.includes('cast-datetime')) {
+                field.type = 'dateTime';
+            }
+        }
         return result;
     }
     async readOne(collection, field) {
@@ -184,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,
@@ -199,211 +212,227 @@ class FieldsService {
         if (this.accountability && this.accountability.admin !== true) {
             throw new exceptions_1.ForbiddenException();
         }
-        const exists = field.field in this.schema.collections[collection].fields ||
-            (0, lodash_1.isNil)(await this.knex.select('id').from('directus_fields').where({ collection, field: field.field }).first()) ===
-                false;
-        // Check if field already exists, either as a column, or as a row in directus_fields
-        if (exists) {
-            throw new exceptions_1.InvalidPayloadException(`Field "${field.field}" already exists in collection "${collection}"`);
-        }
-        await this.knex.transaction(async (trx) => {
-            const itemsService = new items_1.ItemsService('directus_fields', {
-                knex: trx,
-                accountability: this.accountability,
-                schema: this.schema,
+        try {
+            const exists = field.field in this.schema.collections[collection].fields ||
+                (0, lodash_1.isNil)(await this.knex.select('id').from('directus_fields').where({ collection, field: field.field }).first()) === false;
+            // Check if field already exists, either as a column, or as a row in directus_fields
+            if (exists) {
+                throw new exceptions_1.InvalidPayloadException(`Field "${field.field}" already exists in collection "${collection}"`);
+            }
+            // Add flag for specific database type overrides
+            const flagToAdd = this.helpers.date.fieldFlagForField(field.type);
+            if (flagToAdd) {
+                (0, utils_1.addFieldFlag)(field, flagToAdd);
+            }
+            await this.knex.transaction(async (trx) => {
+                const itemsService = new items_1.ItemsService('directus_fields', {
+                    knex: trx,
+                    accountability: this.accountability,
+                    schema: this.schema,
+                });
+                const hookAdjustedField = await emitter_1.default.emitFilter(`fields.create`, field, {
+                    collection: collection,
+                }, {
+                    database: trx,
+                    schema: this.schema,
+                    accountability: this.accountability,
+                });
+                if (hookAdjustedField.type && constants_1.ALIAS_TYPES.includes(hookAdjustedField.type) === false) {
+                    if (table) {
+                        this.addColumnToTable(table, hookAdjustedField);
+                    }
+                    else {
+                        await trx.schema.alterTable(collection, (table) => {
+                            this.addColumnToTable(table, hookAdjustedField);
+                        });
+                    }
+                }
+                if (hookAdjustedField.meta) {
+                    await itemsService.createOne({
+                        ...hookAdjustedField.meta,
+                        collection: collection,
+                        field: hookAdjustedField.field,
+                    }, { emitEvents: false });
+                }
+                emitter_1.default.emitAction(`fields.create`, {
+                    payload: hookAdjustedField,
+                    key: hookAdjustedField.field,
+                    collection: collection,
+                }, {
+                    database: (0, database_1.default)(),
+                    schema: this.schema,
+                    accountability: this.accountability,
+                });
             });
-            const hookAdjustedField = await emitter_1.default.emitFilter(`fields.create`, field, {
+        }
+        finally {
+            if (this.cache && env_1.default.CACHE_AUTO_PURGE) {
+                await this.cache.clear();
+            }
+            await (0, cache_1.clearSystemCache)();
+        }
+    }
+    async updateField(collection, field) {
+        if (this.accountability && this.accountability.admin !== true) {
+            throw new exceptions_1.ForbiddenException();
+        }
+        try {
+            const hookAdjustedField = await emitter_1.default.emitFilter(`fields.update`, field, {
+                keys: [field.field],
                 collection: collection,
             }, {
-                database: trx,
+                database: this.knex,
                 schema: this.schema,
                 accountability: this.accountability,
             });
-            if (hookAdjustedField.type && constants_1.ALIAS_TYPES.includes(hookAdjustedField.type) === false) {
-                if (table) {
-                    this.addColumnToTable(table, hookAdjustedField);
-                }
-                else {
-                    await trx.schema.alterTable(collection, (table) => {
-                        this.addColumnToTable(table, hookAdjustedField);
-                    });
+            const record = field.meta
+                ? await this.knex.select('id').from('directus_fields').where({ collection, field: field.field }).first()
+                : null;
+            if (hookAdjustedField.schema) {
+                const existingColumn = await this.schemaInspector.columnInfo(collection, hookAdjustedField.field);
+                if (!(0, lodash_1.isEqual)(existingColumn, hookAdjustedField.schema)) {
+                    try {
+                        await this.knex.schema.alterTable(collection, (table) => {
+                            if (!hookAdjustedField.schema)
+                                return;
+                            this.addColumnToTable(table, field, existingColumn);
+                        });
+                    }
+                    catch (err) {
+                        throw await (0, translate_1.translateDatabaseError)(err);
+                    }
                 }
             }
             if (hookAdjustedField.meta) {
-                await itemsService.createOne({
-                    ...hookAdjustedField.meta,
-                    collection: collection,
-                    field: hookAdjustedField.field,
-                }, { emitEvents: false });
+                if (record) {
+                    await this.itemsService.updateOne(record.id, {
+                        ...hookAdjustedField.meta,
+                        collection: collection,
+                        field: hookAdjustedField.field,
+                    }, { emitEvents: false });
+                }
+                else {
+                    await this.itemsService.createOne({
+                        ...hookAdjustedField.meta,
+                        collection: collection,
+                        field: hookAdjustedField.field,
+                    }, { emitEvents: false });
+                }
             }
-            emitter_1.default.emitAction(`fields.create`, {
+            emitter_1.default.emitAction(`fields.update`, {
                 payload: hookAdjustedField,
-                key: hookAdjustedField.field,
+                keys: [hookAdjustedField.field],
                 collection: collection,
             }, {
                 database: (0, database_1.default)(),
                 schema: this.schema,
                 accountability: this.accountability,
             });
-        });
-        if (this.cache && env_1.default.CACHE_AUTO_PURGE) {
-            await this.cache.clear();
-        }
-        await (0, cache_1.clearSystemCache)();
-    }
-    async updateField(collection, field) {
-        if (this.accountability && this.accountability.admin !== true) {
-            throw new exceptions_1.ForbiddenException();
+            return field.field;
         }
-        const hookAdjustedField = await emitter_1.default.emitFilter(`fields.update`, field, {
-            keys: [field.field],
-            collection: collection,
-        }, {
-            database: this.knex,
-            schema: this.schema,
-            accountability: this.accountability,
-        });
-        const record = field.meta
-            ? await this.knex.select('id').from('directus_fields').where({ collection, field: field.field }).first()
-            : null;
-        if (hookAdjustedField.schema) {
-            const existingColumn = await this.schemaInspector.columnInfo(collection, hookAdjustedField.field);
-            if (!(0, lodash_1.isEqual)(existingColumn, hookAdjustedField.schema)) {
-                try {
-                    await this.knex.schema.alterTable(collection, (table) => {
-                        if (!hookAdjustedField.schema)
-                            return;
-                        this.addColumnToTable(table, field, existingColumn);
-                    });
-                }
-                catch (err) {
-                    throw await (0, translate_1.translateDatabaseError)(err);
-                }
-            }
-        }
-        if (hookAdjustedField.meta) {
-            if (record) {
-                await this.itemsService.updateOne(record.id, {
-                    ...hookAdjustedField.meta,
-                    collection: collection,
-                    field: hookAdjustedField.field,
-                }, { emitEvents: false });
-            }
-            else {
-                await this.itemsService.createOne({
-                    ...hookAdjustedField.meta,
-                    collection: collection,
-                    field: hookAdjustedField.field,
-                }, { emitEvents: false });
+        finally {
+            if (this.cache && env_1.default.CACHE_AUTO_PURGE) {
+                await this.cache.clear();
             }
+            await (0, cache_1.clearSystemCache)();
         }
-        if (this.cache && env_1.default.CACHE_AUTO_PURGE) {
-            await this.cache.clear();
-        }
-        await (0, cache_1.clearSystemCache)();
-        emitter_1.default.emitAction(`fields.update`, {
-            payload: hookAdjustedField,
-            keys: [hookAdjustedField.field],
-            collection: collection,
-        }, {
-            database: (0, database_1.default)(),
-            schema: this.schema,
-            accountability: this.accountability,
-        });
-        return field.field;
     }
     async deleteField(collection, field) {
         if (this.accountability && this.accountability.admin !== true) {
             throw new exceptions_1.ForbiddenException();
         }
-        await emitter_1.default.emitFilter('fields.delete', [field], {
-            collection: collection,
-        }, {
-            database: this.knex,
-            schema: this.schema,
-            accountability: this.accountability,
-        });
-        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) ||
-                    (relation.related_collection === collection && ((_a = relation.meta) === null || _a === void 0 ? void 0 : _a.one_field) === field));
-            });
-            const relationsService = new relations_1.RelationsService({
-                knex: trx,
-                accountability: this.accountability,
+        try {
+            await emitter_1.default.emitFilter('fields.delete', [field], {
+                collection: collection,
+            }, {
+                database: this.knex,
                 schema: this.schema,
-            });
-            const fieldsService = new FieldsService({
-                knex: trx,
                 accountability: this.accountability,
-                schema: this.schema,
             });
-            for (const relation of relations) {
-                const isM2O = relation.collection === collection && relation.field === field;
-                // If the current field is a m2o, delete the related o2m if it exists and remove the relationship
-                if (isM2O) {
-                    await relationsService.deleteOne(collection, field);
-                    if (relation.related_collection && ((_a = relation.meta) === null || _a === void 0 ? void 0 : _a.one_field)) {
-                        await fieldsService.deleteField(relation.related_collection, relation.meta.one_field);
+            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) ||
+                        (relation.related_collection === collection && ((_a = relation.meta) === null || _a === void 0 ? void 0 : _a.one_field) === field));
+                });
+                const relationsService = new relations_1.RelationsService({
+                    knex: trx,
+                    accountability: this.accountability,
+                    schema: this.schema,
+                });
+                const fieldsService = new FieldsService({
+                    knex: trx,
+                    accountability: this.accountability,
+                    schema: this.schema,
+                });
+                for (const relation of relations) {
+                    const isM2O = relation.collection === collection && relation.field === field;
+                    // If the current field is a m2o, delete the related o2m if it exists and remove the relationship
+                    if (isM2O) {
+                        await relationsService.deleteOne(collection, field);
+                        if (relation.related_collection && ((_a = relation.meta) === null || _a === void 0 ? void 0 : _a.one_field)) {
+                            await fieldsService.deleteField(relation.related_collection, relation.meta.one_field);
+                        }
+                    }
+                    // If the current field is a o2m, just delete the one field config from the relation
+                    if (!isM2O && ((_b = relation.meta) === null || _b === void 0 ? void 0 : _b.one_field)) {
+                        await trx('directus_relations')
+                            .update({ one_field: null })
+                            .where({ many_collection: relation.collection, many_field: relation.field });
                     }
                 }
-                // If the current field is a o2m, just delete the one field config from the relation
-                if (!isM2O && ((_b = relation.meta) === null || _b === void 0 ? void 0 : _b.one_field)) {
-                    await trx('directus_relations')
-                        .update({ one_field: null })
-                        .where({ many_collection: relation.collection, many_field: relation.field });
+                const collectionMeta = await trx
+                    .select('archive_field', 'sort_field')
+                    .from('directus_collections')
+                    .where({ collection })
+                    .first();
+                const collectionMetaUpdates = {};
+                if ((collectionMeta === null || collectionMeta === void 0 ? void 0 : collectionMeta.archive_field) === field) {
+                    collectionMetaUpdates.archive_field = null;
                 }
+                if ((collectionMeta === null || collectionMeta === void 0 ? void 0 : collectionMeta.sort_field) === field) {
+                    collectionMetaUpdates.sort_field = null;
+                }
+                if (Object.keys(collectionMetaUpdates).length > 0) {
+                    await trx('directus_collections').update(collectionMetaUpdates).where({ collection });
+                }
+                // Cleanup directus_fields
+                const metaRow = await trx
+                    .select('collection', 'field')
+                    .from('directus_fields')
+                    .where({ collection, field })
+                    .first();
+                if (metaRow) {
+                    // Handle recursive FK constraints
+                    await trx('directus_fields')
+                        .update({ group: null })
+                        .where({ group: metaRow.field, collection: metaRow.collection });
+                }
+                await trx('directus_fields').delete().where({ collection, field });
+            });
+            emitter_1.default.emitAction('fields.delete', {
+                payload: [field],
+                collection: collection,
+            }, {
+                database: this.knex,
+                schema: this.schema,
+                accountability: this.accountability,
+            });
+        }
+        finally {
+            if (this.cache && env_1.default.CACHE_AUTO_PURGE) {
+                await this.cache.clear();
             }
-            const collectionMeta = await trx
-                .select('archive_field', 'sort_field')
-                .from('directus_collections')
-                .where({ collection })
-                .first();
-            const collectionMetaUpdates = {};
-            if ((collectionMeta === null || collectionMeta === void 0 ? void 0 : collectionMeta.archive_field) === field) {
-                collectionMetaUpdates.archive_field = null;
-            }
-            if ((collectionMeta === null || collectionMeta === void 0 ? void 0 : collectionMeta.sort_field) === field) {
-                collectionMetaUpdates.sort_field = null;
-            }
-            if (Object.keys(collectionMetaUpdates).length > 0) {
-                await trx('directus_collections').update(collectionMetaUpdates).where({ collection });
-            }
-            // Cleanup directus_fields
-            const metaRow = await trx
-                .select('collection', 'field')
-                .from('directus_fields')
-                .where({ collection, field })
-                .first();
-            if (metaRow) {
-                // Handle recursive FK constraints
-                await trx('directus_fields')
-                    .update({ group: null })
-                    .where({ group: metaRow.field, collection: metaRow.collection });
-            }
-            await trx('directus_fields').delete().where({ collection, field });
-        });
-        if (this.cache && env_1.default.CACHE_AUTO_PURGE) {
-            await this.cache.clear();
-        }
-        await (0, cache_1.clearSystemCache)();
-        emitter_1.default.emitAction('fields.delete', {
-            payload: [field],
-            collection: collection,
-        }, {
-            database: this.knex,
-            schema: this.schema,
-            accountability: this.accountability,
-        });
+            await (0, cache_1.clearSystemCache)();
+        }
     }
     addColumnToTable(table, field, alter = null) {
         var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
@@ -441,9 +470,16 @@ class FieldsService {
             column = table[field.type](field.field);
         }
         if (((_f = field.schema) === null || _f === void 0 ? void 0 : _f.default_value) !== undefined) {
-            if (typeof field.schema.default_value === 'string' && field.schema.default_value.toLowerCase() === 'now()') {
+            if (typeof field.schema.default_value === 'string' &&
+                (field.schema.default_value.toLowerCase() === 'now()' || field.schema.default_value === 'CURRENT_TIMESTAMP')) {
                 column.defaultTo(this.knex.fn.now());
             }
+            else if (typeof field.schema.default_value === 'string' &&
+                field.schema.default_value.includes('CURRENT_TIMESTAMP(') &&
+                field.schema.default_value.includes(')')) {
+                const precision = field.schema.default_value.match(constants_2.REGEX_BETWEEN_PARENS)[1];
+                column.defaultTo(this.knex.fn.now(Number(precision)));
+            }
             else if (typeof field.schema.default_value === 'string' &&
                 ['"null"', 'null'].includes(field.schema.default_value.toLowerCase())) {
                 column.defaultTo(null);

package/dist/services/files.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import { AbstractServiceOptions, File, PrimaryKey, MutationOptions } from '../types';
+import { AbstractServiceOptions, File, PrimaryKey, MutationOptions, Metadata } from '../types';
 import { ItemsService } from './items';
 export declare class FilesService extends ItemsService {
     constructor(options: AbstractServiceOptions);
@@ -10,6 +10,10 @@ export declare class FilesService extends ItemsService {
         filename_download: string;
         storage: string;
     }, primaryKey?: PrimaryKey, opts?: MutationOptions): Promise<PrimaryKey>;
+    /**
+     * Extract metadata from a buffer's content
+     */
+    getMetadata(bufferContent: any, allowList?: any): Promise<Metadata>;
     /**
      * Import a single file from an external URL
      */

package/dist/services/files.js

@@ -88,46 +88,13 @@ class FilesService extends items_1.ItemsService {
         payload.filesize = size;
         if (['image/jpeg', 'image/png', 'image/webp', 'image/gif', 'image/tiff'].includes(payload.type)) {
             const buffer = await storage_1.default.disk(data.storage).getBuffer(payload.filename_disk);
-            try {
-                const meta = await (0, sharp_1.default)(buffer.content, {}).metadata();
-                if (meta.orientation && meta.orientation >= 5) {
-                    payload.height = meta.width;
-                    payload.width = meta.height;
-                }
-                else {
-                    payload.width = meta.width;
-                    payload.height = meta.height;
-                }
-            }
-            catch (err) {
-                logger_1.default.warn(`Couldn't extract sharp metadata from file`);
-                logger_1.default.warn(err);
-            }
-            payload.metadata = {};
-            try {
-                payload.metadata = await exifr_1.default.parse(buffer.content, {
-                    icc: false,
-                    iptc: true,
-                    ifd1: true,
-                    interop: true,
-                    translateValues: true,
-                    reviveValues: true,
-                    mergeOutput: false,
-                });
-                if ((_b = (_a = payload.metadata) === null || _a === void 0 ? void 0 : _a.iptc) === null || _b === void 0 ? void 0 : _b.Headline) {
-                    payload.title = payload.metadata.iptc.Headline;
-                }
-                if (!payload.description && ((_d = (_c = payload.metadata) === null || _c === void 0 ? void 0 : _c.iptc) === null || _d === void 0 ? void 0 : _d.Caption)) {
-                    payload.description = payload.metadata.iptc.Caption;
-                }
-                if ((_f = (_e = payload.metadata) === null || _e === void 0 ? void 0 : _e.iptc) === null || _f === void 0 ? void 0 : _f.Keywords) {
-                    payload.tags = payload.metadata.iptc.Keywords;
-                }
-            }
-            catch (err) {
-                logger_1.default.warn(`Couldn't extract EXIF metadata from file`);
-                logger_1.default.warn(err);
-            }
+            const { height, width, description, title, tags, metadata } = await this.getMetadata(buffer.content);
+            (_a = payload.height) !== null && _a !== void 0 ? _a : (payload.height = height);
+            (_b = payload.width) !== null && _b !== void 0 ? _b : (payload.width = width);
+            (_c = payload.description) !== null && _c !== void 0 ? _c : (payload.description = description);
+            (_d = payload.title) !== null && _d !== void 0 ? _d : (payload.title = title);
+            (_e = payload.tags) !== null && _e !== void 0 ? _e : (payload.tags = tags);
+            (_f = payload.metadata) !== null && _f !== void 0 ? _f : (payload.metadata = metadata);
         }
         // We do this in a service without accountability. Even if you don't have update permissions to the file,
         // we still want to be able to set the extracted values from the file on create
@@ -152,6 +119,58 @@ class FilesService extends items_1.ItemsService {
         }
         return primaryKey;
     }
+    /**
+     * Extract metadata from a buffer's content
+     */
+    async getMetadata(bufferContent, allowList = env_1.default.FILE_METADATA_ALLOW_LIST) {
+        const metadata = {};
+        try {
+            const sharpMetadata = await (0, sharp_1.default)(bufferContent, {}).metadata();
+            if (sharpMetadata.orientation && sharpMetadata.orientation >= 5) {
+                metadata.height = sharpMetadata.width;
+                metadata.width = sharpMetadata.height;
+            }
+            else {
+                metadata.width = sharpMetadata.width;
+                metadata.height = sharpMetadata.height;
+            }
+        }
+        catch (err) {
+            logger_1.default.warn(`Couldn't extract sharp metadata from file`);
+            logger_1.default.warn(err);
+        }
+        try {
+            const exifrMetadata = await exifr_1.default.parse(bufferContent, {
+                icc: false,
+                iptc: true,
+                ifd1: true,
+                interop: true,
+                translateValues: true,
+                reviveValues: true,
+                mergeOutput: false,
+            });
+            if (allowList === '*' || (allowList === null || allowList === void 0 ? void 0 : allowList[0]) === '*') {
+                metadata.metadata = exifrMetadata;
+            }
+            else {
+                metadata.metadata = (0, lodash_1.pick)(exifrMetadata, allowList);
+            }
+            if (!metadata.description && (exifrMetadata === null || exifrMetadata === void 0 ? void 0 : exifrMetadata.Caption)) {
+                metadata.description = exifrMetadata.Caption;
+            }
+            if (exifrMetadata === null || exifrMetadata === void 0 ? void 0 : exifrMetadata.Headline) {
+                metadata.title = exifrMetadata.Headline;
+            }
+            if (exifrMetadata === null || exifrMetadata === void 0 ? void 0 : exifrMetadata.Keywords) {
+                metadata.tags = exifrMetadata.Keywords;
+            }
+        }
+        catch (err) {
+            logger_1.default.warn(`Couldn't extract EXIF metadata from file`);
+            logger_1.default.warn(err);
+        }
+        return metadata;
+    }
     /**
      * Import a single file from an external URL
      */

package/dist/services/graphql.d.ts

@@ -1,9 +1,8 @@
+import { BaseException } from '@directus/shared/exceptions';
+import { Accountability, Query, SchemaOverview } from '@directus/shared/types';
 import { ArgumentNode, FormattedExecutionResult, FragmentDefinitionNode, GraphQLError, GraphQLResolveInfo, GraphQLScalarType, GraphQLSchema, ObjectFieldNode, SelectionNode } from 'graphql';
-import { SchemaOverview } from '@directus/shared/types';
 import { ObjectTypeComposer, SchemaComposer } from 'graphql-compose';
 import { Knex } from 'knex';
-import { BaseException } from '@directus/shared/exceptions';
-import { Accountability, Query } from '@directus/shared/types';
 import { AbstractServiceOptions, GraphQLParams, Item } from '../types';
 import { ItemsService } from './items';
 export declare const GraphQLGeoJSON: GraphQLScalarType;