Add schema, rest/gql resolvers for insights

api/src/app.ts

@@ -5,17 +5,28 @@ import expressLogger from 'express-pino-logger';
 import fse from 'fs-extra';
 import path from 'path';
 import qs from 'qs';
+
+import { emitAsyncSafe } from './emitter';
+import { initializeExtensions, registerExtensionEndpoints, registerExtensionHooks } from './extensions';
+import { InvalidPayloadException } from './exceptions';
+import { isInstalled, validateDBConnection } from './database';
+import { register as registerWebhooks } from './webhooks';
+import env from './env';
+import logger from './logger';
+
 import activityRouter from './controllers/activity';
 import assetsRouter from './controllers/assets';
 import authRouter from './controllers/auth';
 import collectionsRouter from './controllers/collections';
 import extensionsRouter from './controllers/extensions';
+import dashboardsRouter from './controllers/dashboards';
 import fieldsRouter from './controllers/fields';
 import filesRouter from './controllers/files';
 import foldersRouter from './controllers/folders';
 import graphqlRouter from './controllers/graphql';
 import itemsRouter from './controllers/items';
 import notFoundHandler from './controllers/not-found';
+import panelsRouter from './controllers/panels';
 import permissionsRouter from './controllers/permissions';
 import presetsRouter from './controllers/presets';
 import relationsRouter from './controllers/relations';
@@ -26,25 +37,20 @@ import settingsRouter from './controllers/settings';
 import usersRouter from './controllers/users';
 import utilsRouter from './controllers/utils';
 import webhooksRouter from './controllers/webhooks';
-import { isInstalled, validateDBConnection } from './database';
-import { emitAsyncSafe } from './emitter';
-import env from './env';
-import { InvalidPayloadException } from './exceptions';
-import { initializeExtensions, registerExtensionEndpoints, registerExtensionHooks } from './extensions';
-import logger from './logger';
+
+import { checkIP } from './middleware/check-ip';
+import { session } from './middleware/session';
 import authenticate from './middleware/authenticate';
 import cache from './middleware/cache';
-import { checkIP } from './middleware/check-ip';
 import cors from './middleware/cors';
 import errorHandler from './middleware/error-handler';
 import extractToken from './middleware/extract-token';
 import rateLimiter from './middleware/rate-limiter';
 import sanitizeQuery from './middleware/sanitize-query';
 import schema from './middleware/schema';
+
 import { track } from './utils/track';
 import { validateEnv } from './utils/validate-env';
-import { register as registerWebhooks } from './webhooks';
-import { session } from './middleware/session';
 
 export default async function createApp(): Promise<express.Application> {
 	validateEnv(['KEY', 'SECRET']);
@@ -152,11 +158,13 @@ export default async function createApp(): Promise<express.Application> {
 	app.use('/activity', activityRouter);
 	app.use('/assets', assetsRouter);
 	app.use('/collections', collectionsRouter);
+	app.use('/dashboards', dashboardsRouter);
 	app.use('/extensions', extensionsRouter);
 	app.use('/fields', fieldsRouter);
 	app.use('/files', filesRouter);
 	app.use('/folders', foldersRouter);
 	app.use('/items', itemsRouter);
+	app.use('/panels', panelsRouter);
 	app.use('/permissions', permissionsRouter);
 	app.use('/presets', presetsRouter);
 	app.use('/relations', relationsRouter);

api/src/controllers/dashboards.ts

@@ -0,0 +1,184 @@
+import express from 'express';
+import { ForbiddenException } from '../exceptions';
+import { respond } from '../middleware/respond';
+import useCollection from '../middleware/use-collection';
+import { validateBatch } from '../middleware/validate-batch';
+import { MetaService, DashboardsService } from '../services';
+import { PrimaryKey } from '../types';
+import asyncHandler from '../utils/async-handler';
+
+const router = express.Router();
+
+router.use(useCollection('directus_dashboards'));
+
+router.post(
+	'/',
+	asyncHandler(async (req, res, next) => {
+		const service = new DashboardsService({
+			accountability: req.accountability,
+			schema: req.schema,
+		});
+
+		const savedKeys: PrimaryKey[] = [];
+
+		if (Array.isArray(req.body)) {
+			const keys = await service.createMany(req.body);
+			savedKeys.push(...keys);
+		} else {
+			const key = await service.createOne(req.body);
+			savedKeys.push(key);
+		}
+
+		try {
+			if (Array.isArray(req.body)) {
+				const items = await service.readMany(savedKeys, req.sanitizedQuery);
+				res.locals.payload = { data: items };
+			} else {
+				const item = await service.readOne(savedKeys[0], req.sanitizedQuery);
+				res.locals.payload = { data: item };
+			}
+		} catch (error) {
+			if (error instanceof ForbiddenException) {
+				return next();
+			}
+
+			throw error;
+		}
+
+		return next();
+	}),
+	respond
+);
+
+const readHandler = asyncHandler(async (req, res, next) => {
+	const service = new DashboardsService({
+		accountability: req.accountability,
+		schema: req.schema,
+	});
+	const metaService = new MetaService({
+		accountability: req.accountability,
+		schema: req.schema,
+	});
+
+	const records = await service.readByQuery(req.sanitizedQuery);
+	const meta = await metaService.getMetaForQuery(req.collection, req.sanitizedQuery);
+
+	res.locals.payload = { data: records || null, meta };
+	return next();
+});
+
+router.get('/', validateBatch('read'), readHandler, respond);
+router.search('/', validateBatch('read'), readHandler, respond);
+
+router.get(
+	'/:pk',
+	asyncHandler(async (req, res, next) => {
+		const service = new DashboardsService({
+			accountability: req.accountability,
+			schema: req.schema,
+		});
+
+		const record = await service.readOne(req.params.pk, req.sanitizedQuery);
+
+		res.locals.payload = { data: record || null };
+		return next();
+	}),
+	respond
+);
+
+router.patch(
+	'/',
+	validateBatch('update'),
+	asyncHandler(async (req, res, next) => {
+		const service = new DashboardsService({
+			accountability: req.accountability,
+			schema: req.schema,
+		});
+
+		let keys: PrimaryKey[] = [];
+
+		if (req.body.keys) {
+			keys = await service.updateMany(req.body.keys, req.body.data);
+		} else {
+			keys = await service.updateByQuery(req.body.query, req.body.data);
+		}
+
+		try {
+			const result = await service.readMany(keys, req.sanitizedQuery);
+			res.locals.payload = { data: result };
+		} catch (error) {
+			if (error instanceof ForbiddenException) {
+				return next();
+			}
+
+			throw error;
+		}
+
+		return next();
+	}),
+	respond
+);
+
+router.patch(
+	'/:pk',
+	asyncHandler(async (req, res, next) => {
+		const service = new DashboardsService({
+			accountability: req.accountability,
+			schema: req.schema,
+		});
+
+		const primaryKey = await service.updateOne(req.params.pk, req.body);
+
+		try {
+			const item = await service.readOne(primaryKey, req.sanitizedQuery);
+			res.locals.payload = { data: item || null };
+		} catch (error) {
+			if (error instanceof ForbiddenException) {
+				return next();
+			}
+
+			throw error;
+		}
+
+		return next();
+	}),
+	respond
+);
+
+router.delete(
+	'/',
+	asyncHandler(async (req, res, next) => {
+		const service = new DashboardsService({
+			accountability: req.accountability,
+			schema: req.schema,
+		});
+
+		if (Array.isArray(req.body)) {
+			await service.deleteMany(req.body);
+		} else if (req.body.keys) {
+			await service.deleteMany(req.body.keys);
+		} else {
+			await service.deleteByQuery(req.body.query);
+		}
+
+		return next();
+	}),
+	respond
+);
+
+router.delete(
+	'/:pk',
+	asyncHandler(async (req, res, next) => {
+		const service = new DashboardsService({
+			accountability: req.accountability,
+			schema: req.schema,
+		});
+
+		await service.deleteOne(req.params.pk);
+
+		return next();
+	}),
+	respond
+);
+
+export default router;

api/src/controllers/panels.ts

@@ -0,0 +1,184 @@
+import express from 'express';
+import { ForbiddenException } from '../exceptions';
+import { respond } from '../middleware/respond';
+import useCollection from '../middleware/use-collection';
+import { validateBatch } from '../middleware/validate-batch';
+import { MetaService, PanelsService } from '../services';
+import { PrimaryKey } from '../types';
+import asyncHandler from '../utils/async-handler';
+
+const router = express.Router();
+
+router.use(useCollection('directus_panels'));
+
+router.post(
+	'/',
+	asyncHandler(async (req, res, next) => {
+		const service = new PanelsService({
+			accountability: req.accountability,
+			schema: req.schema,
+		});
+
+		const savedKeys: PrimaryKey[] = [];
+
+		if (Array.isArray(req.body)) {
+			const keys = await service.createMany(req.body);
+			savedKeys.push(...keys);
+		} else {
+			const key = await service.createOne(req.body);
+			savedKeys.push(key);
+		}
+
+		try {
+			if (Array.isArray(req.body)) {
+				const items = await service.readMany(savedKeys, req.sanitizedQuery);
+				res.locals.payload = { data: items };
+			} else {
+				const item = await service.readOne(savedKeys[0], req.sanitizedQuery);
+				res.locals.payload = { data: item };
+			}
+		} catch (error) {
+			if (error instanceof ForbiddenException) {
+				return next();
+			}
+
+			throw error;
+		}
+
+		return next();
+	}),
+	respond
+);
+
+const readHandler = asyncHandler(async (req, res, next) => {
+	const service = new PanelsService({
+		accountability: req.accountability,
+		schema: req.schema,
+	});
+	const metaService = new MetaService({
+		accountability: req.accountability,
+		schema: req.schema,
+	});
+
+	const records = await service.readByQuery(req.sanitizedQuery);
+	const meta = await metaService.getMetaForQuery(req.collection, req.sanitizedQuery);
+
+	res.locals.payload = { data: records || null, meta };
+	return next();
+});
+
+router.get('/', validateBatch('read'), readHandler, respond);
+router.search('/', validateBatch('read'), readHandler, respond);
+
+router.get(
+	'/:pk',
+	asyncHandler(async (req, res, next) => {
+		const service = new PanelsService({
+			accountability: req.accountability,
+			schema: req.schema,
+		});
+
+		const record = await service.readOne(req.params.pk, req.sanitizedQuery);
+
+		res.locals.payload = { data: record || null };
+		return next();
+	}),
+	respond
+);
+
+router.patch(
+	'/',
+	validateBatch('update'),
+	asyncHandler(async (req, res, next) => {
+		const service = new PanelsService({
+			accountability: req.accountability,
+			schema: req.schema,
+		});
+
+		let keys: PrimaryKey[] = [];
+
+		if (req.body.keys) {
+			keys = await service.updateMany(req.body.keys, req.body.data);
+		} else {
+			keys = await service.updateByQuery(req.body.query, req.body.data);
+		}
+
+		try {
+			const result = await service.readMany(keys, req.sanitizedQuery);
+			res.locals.payload = { data: result };
+		} catch (error) {
+			if (error instanceof ForbiddenException) {
+				return next();
+			}
+
+			throw error;
+		}
+
+		return next();
+	}),
+	respond
+);
+
+router.patch(
+	'/:pk',
+	asyncHandler(async (req, res, next) => {
+		const service = new PanelsService({
+			accountability: req.accountability,
+			schema: req.schema,
+		});
+
+		const primaryKey = await service.updateOne(req.params.pk, req.body);
+
+		try {
+			const item = await service.readOne(primaryKey, req.sanitizedQuery);
+			res.locals.payload = { data: item || null };
+		} catch (error) {
+			if (error instanceof ForbiddenException) {
+				return next();
+			}
+
+			throw error;
+		}
+
+		return next();
+	}),
+	respond
+);
+
+router.delete(
+	'/',
+	asyncHandler(async (req, res, next) => {
+		const service = new PanelsService({
+			accountability: req.accountability,
+			schema: req.schema,
+		});
+
+		if (Array.isArray(req.body)) {
+			await service.deleteMany(req.body);
+		} else if (req.body.keys) {
+			await service.deleteMany(req.body.keys);
+		} else {
+			await service.deleteByQuery(req.body.query);
+		}
+
+		return next();
+	}),
+	respond
+);
+
+router.delete(
+	'/:pk',
+	asyncHandler(async (req, res, next) => {
+		const service = new PanelsService({
+			accountability: req.accountability,
+			schema: req.schema,
+		});
+
+		await service.deleteOne(req.params.pk);
+
+		return next();
+	}),
+	respond
+);
+
+export default router;

api/src/database/migrations/20210525A-add-insights.ts

@@ -5,12 +5,13 @@ export async function up(knex: Knex): Promise<void> {
 		table.uuid('id').primary();
 		table.string('name');
 		table.string('icon', 30);
-		table.timestamp('date_created');
-		table.timestamp('user_created');
+		table.timestamp('date_created').defaultTo(knex.fn.now());
+		table.uuid('user_created').references('id').inTable('directus_users').onDelete('SET NULL');
 	});
 
 	await knex.schema.createTable('directus_panels', (table) => {
 		table.uuid('id').primary();
+		table.uuid('dashboard').notNullable().references('id').inTable('directus_dashboards').onDelete('CASCADE');
 		table.string('name');
 		table.string('icon', 30);
 		table.string('color', 10);
@@ -21,8 +22,8 @@ export async function up(knex: Knex): Promise<void> {
 		table.integer('width');
 		table.integer('height');
 		table.json('options');
-		table.timestamp('date_created');
-		table.timestamp('user_created');
+		table.timestamp('date_created').defaultTo(knex.fn.now());
+		table.uuid('user_created').references('id').inTable('directus_users').onDelete('SET NULL');
 	});
 }
 

api/src/database/system-data/fields/dashboards.yaml

@@ -5,6 +5,8 @@ fields:
     special: uuid
   - field: name
   - field: icon
+  - field: panels
+    special: o2m
   - field: date_created
     special: date-created
   - field: user_created

api/src/database/system-data/relations/relations.yaml

@@ -54,3 +54,7 @@ data:
   - many_collection: directus_settings
     many_field: public_background
     one_collection: directus_files
+  - many_collection: directus_panels
+    many_field: dashboard
+    one_collection: directus_dashboards
+    one_field: panels

api/src/services/dashboards.ts

@@ -0,0 +1,8 @@
+import { AbstractServiceOptions } from '../types';
+import { ItemsService } from './items';
+
+export class DashboardsService extends ItemsService {
+	constructor(options: AbstractServiceOptions) {
+		super('directus_dashboards', options);
+	}
+}

api/src/services/index.ts

@@ -2,6 +2,7 @@ export * from './activity';
 export * from './assets';
 export * from './authentication';
 export * from './collections';
+export * from './dashboards';
 export * from './fields';
 export * from './files';
 export * from './folders';
@@ -10,6 +11,7 @@ export * from './import';
 export * from './items';
 export * from './mail';
 export * from './meta';
+export * from './panels';
 export * from './payload';
 export * from './permissions';
 export * from './presets';

api/src/services/items.ts

@@ -130,7 +130,7 @@ export class ItemsService<Item extends AnyItem = AnyItem> implements AbstractSer
 			let primaryKey = payloadWithTypeCasting[primaryKeyField];
 
 			try {
-				await trx.insert(payloadWithoutAliases).into(this.collection);
+				await trx.insert(payloadWithTypeCasting).into(this.collection);
 			} catch (err) {
 				throw await translateDatabaseError(err);
 			}

api/src/services/panels.ts

@@ -0,0 +1,8 @@
+import { AbstractServiceOptions } from '../types';
+import { ItemsService } from './items';
+
+export class PanelsService extends ItemsService {
+	constructor(options: AbstractServiceOptions) {
+		super('directus_panels', options);
+	}
+}