Merge pull request #84 from middlewarehq/shareableLinks

Shareable links

src/api-helpers/persistance.ts

@@ -1,11 +1,13 @@
 import { ImageFile } from '@/types/images';
 import {
   deleteS3Directory,
+  fetchFileFromS3Directory,
   fetchImagesFromS3Directory,
   uploadImagesToS3
 } from '../utils/persistence/s3';
 import {
   deleteLocalDirectory,
+  fetchImageFromLocalDirectory,
   fetchImagesFromLocalDirectory,
   saveImagesToLocalDirectory
 } from '../utils/persistence/file-system';
@@ -52,3 +54,19 @@ export const deleteSaveCards = async (userLogin: string): Promise<void> => {
     );
   }
 };
+
+export const fetchSavedCard = async (
+  userLogin: string,
+  cardName: string
+): Promise<ImageFile> => {
+  if (awsCredentialExists && bucketName) {
+    return await fetchFileFromS3Directory(
+      bucketName,
+      `${userLogin}/${cardName}.png`
+    );
+  } else {
+    return await fetchImageFromLocalDirectory(
+      `${process.cwd()}/unwrapped-cards/${userLogin}/${cardName}.png`
+    );
+  }
+};

src/pages/api/shared/[username]/[cardname].ts

@@ -0,0 +1,38 @@
+import chalk from 'chalk';
+import { NextApiRequest, NextApiResponse } from 'next';
+import { fetchSavedCard } from '@/api-helpers/persistance';
+
+const fetchAndDownloadImageBuffer = async (
+  req: NextApiRequest,
+  res: NextApiResponse
+) => {
+  let username = req.query.username as string;
+  let cardName = req.query.cardname as string;
+
+  if (!username) {
+    return res.status(400).json({
+      message: 'Invalid parameters, must pass valid username.'
+    });
+  }
+
+  try {
+    const cachedCardBuffer = await fetchSavedCard(username, cardName);
+
+    if (!cachedCardBuffer) {
+      return res.status(404).json({
+        message: `Image not found for user ${username} and image name ${cardName}`
+      });
+    }
+
+    res.setHeader('Content-Type', 'image/jpeg');
+    res.setHeader('Content-Length', cachedCardBuffer.data.length);
+    res.send(cachedCardBuffer.data);
+
+    console.log(chalk.green('Successfully sent buffer to client'));
+  } catch (error: any) {
+    console.log(chalk.red('Error fetching or sending buffer:'), error);
+    res.status(error.status || 500).json({ message: error.message });
+  }
+};
+
+export default fetchAndDownloadImageBuffer;

src/utils/persistence/file-system.ts

@@ -69,6 +69,22 @@ export const fetchImagesFromLocalDirectory = async (
   }
 };
 
+export const fetchImageFromLocalDirectory = async (
+  filePath: string
+): Promise<ImageFile> => {
+  try {
+    const data = await fs.readFile(filePath);
+    return {
+      fileName: filePath,
+      data
+    };
+  } catch (error: any) {
+    throw new Error(
+      `Error fetching images from local directory: ${error.message}`
+    );
+  }
+};
+
 export const deleteLocalDirectory = async (
   localDirectory: string
 ): Promise<void> => {

src/utils/persistence/s3.ts

@@ -60,6 +60,24 @@ export const fetchImagesFromS3Directory = async (
   }
 };
 
+export const fetchFileFromS3Directory = async (
+  bucketName: string,
+  key: string
+): Promise<ImageFile> => {
+  try {
+    const imageBuffer = await s3
+      .getObject({ Bucket: bucketName, Key: key })
+      .promise();
+
+    return {
+      fileName: key,
+      data: imageBuffer.Body as Buffer
+    };
+  } catch (error: any) {
+    throw new Error(`Error fetching images from S3: ${error.message}`);
+  }
+};
+
 export const deleteS3Directory = async (
   bucketName: string,
   directory: string