Rename routes to controllers

api/src/controllers/files.ts

@@ -0,0 +1,208 @@
+import express from 'express';
+import asyncHandler from 'express-async-handler';
+import Busboy from 'busboy';
+import sanitizeQuery from '../middleware/sanitize-query';
+import FilesService from '../services/files';
+import MetaService from '../services/meta';
+import useCollection from '../middleware/use-collection';
+import { File, PrimaryKey } from '../types';
+import formatTitle from '@directus/format-title';
+import env from '../env';
+import axios from 'axios';
+import Joi from 'joi';
+import { InvalidPayloadException } from '../exceptions';
+import url from 'url';
+import path from 'path';
+
+const router = express.Router();
+
+router.use(useCollection('directus_files'));
+
+const multipartHandler = asyncHandler(async (req, res, next) => {
+	if (req.is('multipart/form-data') === false) return next();
+
+	const busboy = new Busboy({ headers: req.headers });
+	const savedFiles: PrimaryKey[] = [];
+	const service = new FilesService({ accountability: req.accountability });
+
+	const existingPrimaryKey = req.params.pk || undefined;
+
+	/**
+	 * The order of the fields in multipart/form-data is important. We require that all fields
+	 * are provided _before_ the files. This allows us to set the storage location, and create
+	 * the row in directus_files async during the upload of the actual file.
+	 */
+
+	let disk: string = (env.STORAGE_LOCATIONS as string).split(',')[0].trim();
+	let payload: Partial<File> = {};
+	let fileCount = 0;
+
+	busboy.on('field', (fieldname: keyof File, val) => {
+		if (fieldname === 'storage') {
+			disk = val;
+		}
+
+		payload[fieldname] = val;
+	});
+
+	busboy.on('file', async (fieldname, fileStream, filename, encoding, mimetype) => {
+		fileCount++;
+
+		if (!payload.title) {
+			payload.title = formatTitle(path.parse(filename).name);
+		}
+
+		if (req.accountability?.user) {
+			payload.uploaded_by = req.accountability.user;
+		}
+
+		const payloadWithRequiredFields: Partial<File> & {
+			filename_download: string;
+			type: string;
+			storage: string;
+		} = {
+			...payload,
+			filename_download: filename,
+			type: mimetype,
+			storage: payload.storage || disk,
+		};
+
+		const primaryKey = await service.upload(fileStream, payloadWithRequiredFields, existingPrimaryKey);
+		savedFiles.push(primaryKey);
+		tryDone();
+	});
+
+	busboy.on('error', (error: Error) => {
+		next(error);
+	});
+
+	busboy.on('finish', () => {
+		tryDone();
+	});
+
+	req.pipe(busboy);
+
+	function tryDone() {
+		if (savedFiles.length === fileCount) {
+			res.locals.savedFiles = savedFiles;
+			return next();
+		}
+	}
+});
+
+router.post(
+	'/',
+	sanitizeQuery,
+	multipartHandler,
+	asyncHandler(async (req, res) => {
+		const service = new FilesService({ accountability: req.accountability });
+		let keys: PrimaryKey | PrimaryKey[] = [];
+
+		if (req.is('multipart/form-data')) {
+			keys = res.locals.savedFiles;
+		} else {
+			// @TODO is this ever used in real life? Wouldn't you always upload a file on create?
+			keys = await service.create(req.body);
+		}
+
+		const record = await service.readByKey(keys as any, req.sanitizedQuery);
+
+		return res.json({ data: res.locals.savedFiles.length === 1 ? record[0] : record || null });
+	})
+);
+
+const importSchema = Joi.object({
+	url: Joi.string().required()
+});
+
+router.post(
+	'/import',
+	sanitizeQuery,
+	asyncHandler(async (req, res) => {
+		const { error } = importSchema.validate(req.body);
+
+		if (error) {
+			throw new InvalidPayloadException(error.message);
+		}
+
+		const service = new FilesService({ accountability: req.accountability });
+
+		const fileResponse = await axios.get<NodeJS.ReadableStream>(req.body.url, {
+			responseType: 'stream'
+		});
+
+		const parsedURL = url.parse(fileResponse.request.res.responseUrl);
+		const filename = path.basename(parsedURL.pathname as string);
+
+		const payload = {
+			filename_download: filename,
+			storage: (env.STORAGE_LOCATIONS as string).split(',')[0].trim(),
+			type: fileResponse.headers['content-type'],
+			title: formatTitle(filename),
+			...req.body
+		};
+
+		delete payload.url;
+
+		const primaryKey = await service.upload(fileResponse.data, payload);
+		const record = await service.readByKey(primaryKey, req.sanitizedQuery);
+		return res.json({ data: record || null });
+	})
+)
+
+router.get(
+	'/',
+	sanitizeQuery,
+	asyncHandler(async (req, res) => {
+		const service = new FilesService({ accountability: req.accountability });
+		const metaService = new MetaService({ accountability: req.accountability });
+
+		const records = await service.readByQuery(req.sanitizedQuery);
+		const meta = await metaService.getMetaForQuery(req.collection, req.sanitizedQuery);
+
+		return res.json({ data: records || null, meta });
+	})
+);
+
+router.get(
+	'/:pk',
+	sanitizeQuery,
+	asyncHandler(async (req, res) => {
+		const keys = req.params.pk.includes(',') ? req.params.pk.split(',') : req.params.pk;
+		const service = new FilesService({ accountability: req.accountability });
+		const record = await service.readByKey(keys as any, req.sanitizedQuery);
+		return res.json({ data: record || null });
+	})
+);
+
+router.patch(
+	'/:pk',
+	sanitizeQuery,
+	multipartHandler,
+	asyncHandler(async (req, res) => {
+		const service = new FilesService({ accountability: req.accountability });
+		let keys: PrimaryKey | PrimaryKey[] = [];
+
+		if (req.is('multipart/form-data')) {
+			keys = res.locals.savedFiles;
+		} else {
+			keys = req.params.pk.includes(',') ? req.params.pk.split(',') : req.params.pk;
+			await service.update(req.body, keys as any);
+		}
+
+		const record = await service.readByKey(keys as any, req.sanitizedQuery);
+		return res.json({ data: record || null });
+	})
+);
+
+router.delete(
+	'/:pk',
+	asyncHandler(async (req, res) => {
+		const keys = req.params.pk.includes(',') ? req.params.pk.split(',') : req.params.pk;
+		const service = new FilesService({ accountability: req.accountability });
+		await service.delete(keys as any);
+		return res.status(200).end();
+	})
+);
+
+export default router;