#14 - Added item endpoint, to get item with extra data (Folder, Blob,…

… etc.)

src/locales/da.json

@@ -79,6 +79,10 @@
 			"required": "id er påkrævet",
 			"type": "id skal være et tal"
 		},
+		"parentId": {
+			"required": "Parent id er påkrævet",
+			"type": "Parent id skal være et tal"
+		},
 		"blob": {
 			"notFound": "Blob ikke fundet"
 		},

src/locales/en.json

@@ -79,6 +79,10 @@
 			"required": "id is required",
 			"type": "id must be a number"
 		},
+		"parentId": {
+			"required": "Parent id is required",
+			"type": "Parent id must be a number"
+		},
 		"blob": {
 			"notFound": "Blob not found"
 		},

src/modules/auth/auth.route.ts

@@ -66,13 +66,15 @@ export default async (fastify: FastifyInstance) => {
 		'/user',
 		{
 			schema: {
-				headers: {
-					Authorization: true,
-				},
 				tags: ['Auth'],
 				response: {
 					200: { $ref: 'userResponseSchema' },
 				},
+				security: [
+					{
+						bearerAuth: [],
+					},
+				],
 			},
 			onRequest: [fastify.authenticate],
 		},

src/modules/item/blob/blob.route.ts

@@ -15,16 +15,18 @@ export default async (fastify: FastifyInstance) => {
 		'/:id',
 		{
 			schema: {
-				headers: {
-					Authorization: true,
-				},
 				tags: ['Blob'],
 				params: { $ref: 'readBlobSchema' },
 				response: {
 					200: {
 						$ref: 'readBlobResponseSchema',
 					},
 				},
+				security: [
+					{
+						bearerAuth: [],
+					},
+				],
 			},
 			onRequest: [fastify.authenticate],
 		},
@@ -35,16 +37,18 @@ export default async (fastify: FastifyInstance) => {
 		'/',
 		{
 			schema: {
-				headers: {
-					Authorization: true,
-				},
 				tags: ['Blob'],
 				body: { $ref: 'editBlobSchema' },
 				response: {
 					200: {
 						$ref: 'editBlobResponseSchema',
 					},
 				},
+				security: [
+					{
+						bearerAuth: [],
+					},
+				],
 			},
 			onRequest: [fastify.authenticate],
 		},
@@ -55,14 +59,16 @@ export default async (fastify: FastifyInstance) => {
 		'/',
 		{
 			schema: {
-				headers: {
-					Authorization: true,
-				},
 				tags: ['Blob'],
 				body: { $ref: 'uploadBlobSchema' },
 				response: {
 					200: { $ref: 'uploadBlobResponseSchema' },
 				},
+				security: [
+					{
+						bearerAuth: [],
+					},
+				],
 			},
 		},
 		blobController.addHandler.bind(blobController),
@@ -72,11 +78,13 @@ export default async (fastify: FastifyInstance) => {
 		'/:id',
 		{
 			schema: {
-				headers: {
-					Authorization: true,
-				},
 				tags: ['Blob'],
 				params: { $ref: 'deleteBlobSchema' },
+				security: [
+					{
+						bearerAuth: [],
+					},
+				],
 			},
 			onRequest: [fastify.authenticate],
 		},

src/modules/item/folder/folder.controller.ts

@@ -104,7 +104,7 @@ export default class FolderController {
 				return reply.unauthorized();
 			}
 
-			await this.folderService.deleteFolderByItemId(request.params.id);
+			await this.folderService.deleteFolderByItemId(folder.id);
 			return reply.code(204).send();
 		} catch (e) {
 			if (e instanceof Error) {

src/modules/item/folder/folder.route.ts

@@ -16,14 +16,16 @@ export default async (fastify: FastifyInstance) => {
 		'/:id',
 		{
 			schema: {
-				headers: {
-					Authorization: true,
-				},
 				tags: ['Folder'],
 				params: { $ref: 'readFolderSchema' },
 				response: {
 					200: { $ref: 'readFolderResponseSchema' },
 				},
+				security: [
+					{
+						bearerAuth: [],
+					},
+				],
 			},
 			onRequest: [fastify.authenticate],
 		},
@@ -34,14 +36,16 @@ export default async (fastify: FastifyInstance) => {
 		'/',
 		{
 			schema: {
-				headers: {
-					Authorization: true,
-				},
 				tags: ['Folder'],
 				body: { $ref: 'editFolderSchema' },
 				response: {
 					200: { $ref: 'editFolderResponseSchema' },
 				},
+				security: [
+					{
+						bearerAuth: [],
+					},
+				],
 			},
 			onRequest: [fastify.authenticate],
 		},
@@ -52,14 +56,16 @@ export default async (fastify: FastifyInstance) => {
 		'/',
 		{
 			schema: {
-				headers: {
-					Authorization: true,
-				},
 				tags: ['Folder'],
 				body: { $ref: 'addFolderSchema' },
 				response: {
 					200: { $ref: 'addFolderResponseSchema' },
 				},
+				security: [
+					{
+						bearerAuth: [],
+					},
+				],
 			},
 			onRequest: [fastify.authenticate],
 		},
@@ -70,11 +76,13 @@ export default async (fastify: FastifyInstance) => {
 		'/:id',
 		{
 			schema: {
-				headers: {
-					Authorization: true,
-				},
 				tags: ['Folder'],
 				params: { $ref: 'deleteFolderSchema' },
+				security: [
+					{
+						bearerAuth: [],
+					},
+				],
 			},
 			onRequest: [fastify.authenticate],
 		},

src/modules/item/index.ts

@@ -4,9 +4,17 @@ import folder from './folder';
 import { getOptionsWithPrefix } from '..';
 import blob from './blob';
 import sharing from './sharing';
+import { itemSchemas } from './item.schema';
+import itemRoute from './item.route';
 
 export default fastifyPlugin(async (fastify: FastifyInstance, options: FastifyPluginOptions) => {
 	await fastify.register(blob, getOptionsWithPrefix(options, '/blob'));
 	await fastify.register(folder, getOptionsWithPrefix(options, '/folder'));
 	await fastify.register(sharing, getOptionsWithPrefix(options, '/sharing'));
+
+	for (const schema of itemSchemas) {
+		fastify.addSchema(schema);
+	}
+
+	await fastify.register(itemRoute, options);
 });

src/modules/item/item.controller.ts

@@ -0,0 +1,56 @@
+import { FastifyReply, FastifyRequest } from 'fastify';
+import ItemService from './item.service';
+import { ReadInput } from './item.schema';
+import AccessService from './sharing/access.service';
+
+export default class ItemController {
+	private itemService: ItemService;
+	private accessService: AccessService;
+
+	constructor(itemService: ItemService, accessService: AccessService) {
+		this.itemService = itemService;
+		this.accessService = accessService;
+	}
+
+	public async browseHandler(request: FastifyRequest, reply: FastifyReply) {
+		try {
+			const items = await this.itemService.getByOwnerIdAndParentId(request.user.sub, null);
+
+			return reply.code(200).send(items);
+		} catch (e) {
+			if (e instanceof Error) {
+				return reply.badRequest(request.i18n.t(e.message));
+			}
+
+			/* istanbul ignore next */
+			return reply.badRequest();
+		}
+	}
+
+	public async readHandler(
+		request: FastifyRequest<{
+			Params: ReadInput;
+		}>,
+		reply: FastifyReply,
+	) {
+		try {
+			if (!(await this.accessService.hasAccessToItem(request.params.parentId, request.user.sub))) {
+				return reply.unauthorized();
+			}
+
+			const items = await this.itemService.getByOwnerIdAndParentIdAndSharred(
+				request.user.sub,
+				request.params.parentId,
+			);
+
+			return reply.code(200).send(items);
+		} catch (e) {
+			if (e instanceof Error) {
+				return reply.badRequest(request.i18n.t(e.message));
+			}
+
+			/* istanbul ignore next */
+			return reply.badRequest();
+		}
+	}
+}

src/modules/item/item.route.ts

@@ -0,0 +1,52 @@
+import { FastifyInstance } from 'fastify';
+import ItemController from './item.controller';
+import ItemService from './item.service';
+import AccessService from './sharing/access.service';
+import SharingService from './sharing/sharing.service';
+
+export default async (fastify: FastifyInstance) => {
+	const itemService = new ItemService();
+	const itemController = new ItemController(
+		itemService,
+		new AccessService(itemService, new SharingService()),
+	);
+
+	fastify.get(
+		'/',
+		{
+			schema: {
+				tags: ['Items'],
+				response: {
+					200: { $ref: 'itemsResponseSchema' },
+				},
+				security: [
+					{
+						bearerAuth: [],
+					},
+				],
+			},
+			onRequest: [fastify.authenticate],
+		},
+		itemController.browseHandler.bind(itemController),
+	);
+
+	fastify.get(
+		'/:parentId',
+		{
+			schema: {
+				tags: ['Items'],
+				params: { $ref: 'readItemsSchema' },
+				response: {
+					200: { $ref: 'itemsResponseSchema' },
+				},
+				security: [
+					{
+						bearerAuth: [],
+					},
+				],
+			},
+			onRequest: [fastify.authenticate],
+		},
+		itemController.readHandler.bind(itemController),
+	);
+};