PR for LAMBDA FUNCTIONS

amplify.yml

@@ -5,6 +5,7 @@ backend:
       commands:
         - npm ci --cache .npm --prefer-offline
         - npx ampx pipeline-deploy --branch $AWS_BRANCH --app-id $AWS_APP_ID
+        - npm i
 frontend:
   phases:
     build:

amplify/backend.ts

@@ -1,8 +1,16 @@
-import { defineBackend } from '@aws-amplify/backend';
-import { auth } from './auth/resource.js';
-import { data } from './data/resource.js';
+import { defineBackend } from "@aws-amplify/backend";
+import { auth } from "./auth/resource";
+import { data } from "./data/resource";
+import { deleteDocument } from "./functions/deleteDocument/resource";
+import { downloadDocument } from "./functions/downloadDocument/resource";
+import { fetchDocuments } from "./functions/fetchDocuments/resource";
+import { createDocument } from "./functions/createDocument/resource";
 
 defineBackend({
   auth,
   data,
-});
+  deleteDocument,
+  downloadDocument,
+  fetchDocuments,
+  createDocument
+});

amplify/data/resource.ts

@@ -7,7 +7,7 @@ const schema = a.schema({
       content: a.string(),
     })
     .authorization((allow) => [allow.authenticated()]), // or add allow.apiKey() here if needed
-});
+  });
 
 export const data = defineData({
   schema, // ✅ This now has a value

amplify/functions/createDocument/handler.ts

@@ -0,0 +1,97 @@
+import { APIGatewayProxyEvent, APIGatewayProxyResult } from 'aws-lambda';
+import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
+import { DynamoDBDocumentClient, PutCommand } from "@aws-sdk/lib-dynamodb";
+import { randomUUID } from 'crypto';
+
+const client = new DynamoDBClient({ region: "us-west-1" });
+const docClient = DynamoDBDocumentClient.from(client);
+
+// Get the DynamoDB table name from environment variables
+const tableName = process.env.DOCUMENT_TABLE_NAME || "Document-vnyciacn2nca3b6znjb4pulud4-NONE";
+
+export const handler = async (event: APIGatewayProxyEvent): Promise<APIGatewayProxyResult> => {
+  console.log("Event received:", JSON.stringify(event, null, 2));
+
+  try {
+    // Parse document data from request body
+    if (!event.body) {
+      return {
+        statusCode: 400,
+        headers: {
+          "Content-Type": "application/json",
+          "Access-Control-Allow-Origin": "*",
+          "Access-Control-Allow-Headers": "Content-Type",
+          "Access-Control-Allow-Methods": "POST"
+        },
+        body: JSON.stringify({ error: "Request body is required" })
+      };
+    }
+
+    const requestBody = JSON.parse(event.body);
+
+    // Validate required fields
+    if (!requestBody.title) {
+      return {
+        statusCode: 400,
+        headers: {
+          "Content-Type": "application/json",
+          "Access-Control-Allow-Origin": "*",
+          "Access-Control-Allow-Headers": "Content-Type",
+          "Access-Control-Allow-Methods": "POST"
+        },
+        body: JSON.stringify({ error: "Document title is required" })
+      };
+    }
+
+    // Create document with required fields and timestamps
+    const now = new Date().toISOString();
+    const documentId = requestBody.id || randomUUID();
+
+    const document = {
+      __typename: "Document",
+      id: documentId,
+      title: requestBody.title,
+      content: requestBody.content || "",
+      createdAt: now,
+      updatedAt: now
+    };
+
+    // Put the document in DynamoDB
+    const putParams = {
+      TableName: tableName,
+      Item: document
+    };
+
+    await docClient.send(new PutCommand(putParams));
+
+    return {
+      statusCode: 201,
+      headers: {
+        "Content-Type": "application/json",
+        "Access-Control-Allow-Origin": "*",
+        "Access-Control-Allow-Headers": "Content-Type",
+        "Access-Control-Allow-Methods": "POST"
+      },
+      body: JSON.stringify({
+        message: "Document created successfully",
+        document
+      })
+    };
+  } catch (error: unknown) {
+    console.error("Error creating document:", error);
+
+    return {
+      statusCode: 500,
+      headers: {
+        "Content-Type": "application/json",
+        "Access-Control-Allow-Origin": "*",
+        "Access-Control-Allow-Headers": "Content-Type",
+        "Access-Control-Allow-Methods": "POST"
+      },
+      body: JSON.stringify({ 
+        error: "Failed to create document", 
+        details: error instanceof Error ? error.message : 'Unknown error'
+      })
+    };
+  }
+};

amplify/functions/createDocument/resource.ts

@@ -0,0 +1,6 @@
+import { defineFunction } from "@aws-amplify/backend";
+
+export const createDocument = defineFunction({
+  name: "createDocument",
+  entry: "./handler.ts"
+});

amplify/functions/deleteDocument/handler.ts

@@ -0,0 +1,87 @@
+import { APIGatewayProxyEvent, APIGatewayProxyResult } from 'aws-lambda';
+import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
+import { DynamoDBDocumentClient, DeleteCommand } from "@aws-sdk/lib-dynamodb";
+
+const client = new DynamoDBClient({});
+const docClient = DynamoDBDocumentClient.from(client);
+
+// Get the DynamoDB table name from environment variables
+const tableName = process.env.DOCUMENT_TABLE_NAME || "Document-vnyciacn2nca3b6znjb4pulud4-NONE";
+
+export const handler = async (event: APIGatewayProxyEvent): Promise<APIGatewayProxyResult> => {
+  console.log("Event received:", JSON.stringify(event, null, 2));
+
+  try {
+    // Extract document ID from event
+    const documentId = event.pathParameters?.id || 
+                      JSON.parse(event.body || '{}').id ||
+                      event.queryStringParameters?.id;
+
+    if (!documentId) {
+      return {
+        statusCode: 400,
+        headers: {
+          "Content-Type": "application/json",
+          "Access-Control-Allow-Origin": "*",
+          "Access-Control-Allow-Headers": "Content-Type",
+          "Access-Control-Allow-Methods": "DELETE"
+        },
+        body: JSON.stringify({ error: "Document ID is required" })
+      };
+    }
+
+    // Delete the document from DynamoDB
+    const deleteParams = {
+      TableName: tableName,
+      Key: {
+        id: documentId
+      },
+      ReturnValues: "ALL_OLD" as const // Return the deleted item
+    };
+
+    const { Attributes } = await docClient.send(new DeleteCommand(deleteParams));
+
+    if (!Attributes) {
+      return {
+        statusCode: 404,
+        headers: {
+          "Content-Type": "application/json",
+          "Access-Control-Allow-Origin": "*",
+          "Access-Control-Allow-Headers": "Content-Type",
+          "Access-Control-Allow-Methods": "DELETE"
+        },
+        body: JSON.stringify({ error: "Document not found or already deleted" })
+      };
+    }
+
+    return {
+      statusCode: 200,
+      headers: {
+        "Content-Type": "application/json",
+        "Access-Control-Allow-Origin": "*",
+        "Access-Control-Allow-Headers": "Content-Type",
+        "Access-Control-Allow-Methods": "DELETE"
+      },
+      body: JSON.stringify({
+        message: "Document deleted successfully",
+        deletedDocument: Attributes
+      })
+    };
+  } catch (error: unknown) {
+    console.error("Error deleting document:", error);
+
+    return {
+      statusCode: 500,
+      headers: {
+        "Content-Type": "application/json",
+        "Access-Control-Allow-Origin": "*",
+        "Access-Control-Allow-Headers": "Content-Type",
+        "Access-Control-Allow-Methods": "DELETE"
+      },
+      body: JSON.stringify({ 
+        error: "Failed to delete document", 
+        details: error instanceof Error ? error.message : 'Unknown error'
+      })
+    };
+  }
+};

amplify/functions/deleteDocument/resource.ts

@@ -0,0 +1,6 @@
+import { defineFunction } from "@aws-amplify/backend";
+
+export const deleteDocument = defineFunction({
+  name: "deleteDocument",
+  entry: "./handler.ts"
+});

amplify/functions/downloadDocument/handler.ts

@@ -0,0 +1,89 @@
+import { APIGatewayProxyEvent, APIGatewayProxyResult } from 'aws-lambda';
+import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
+import { DynamoDBDocumentClient, GetCommand } from "@aws-sdk/lib-dynamodb";
+
+const client = new DynamoDBClient({});
+const docClient = DynamoDBDocumentClient.from(client);
+
+// Get the DynamoDB table name from environment variables
+const tableName = process.env.DOCUMENT_TABLE_NAME || "Document-vnyciacn2nca3b6znjb4pulud4-NONE";
+
+export const handler = async (event: APIGatewayProxyEvent): Promise<APIGatewayProxyResult> => {
+  console.log("Event received:", JSON.stringify(event, null, 2));
+
+  try {
+    // Extract document ID from the event
+    const documentId = event.pathParameters?.id || 
+                       event.queryStringParameters?.id ||
+                       JSON.parse(event.body || '{}').id;
+
+    if (!documentId) {
+      return {
+        statusCode: 400,
+        headers: {
+          "Content-Type": "application/json",
+          "Access-Control-Allow-Origin": "*",
+          "Access-Control-Allow-Headers": "Content-Type",
+          "Access-Control-Allow-Methods": "GET"
+        },
+        body: JSON.stringify({ error: "Document ID is required" })
+      };
+    }
+
+    // Get the document from DynamoDB
+    const getParams = {
+      TableName: tableName,
+      Key: {
+        id: documentId
+      }
+    };
+
+    const { Item } = await docClient.send(new GetCommand(getParams));
+
+    if (!Item) {
+      return {
+        statusCode: 404,
+        headers: {
+          "Content-Type": "application/json",
+          "Access-Control-Allow-Origin": "*",
+          "Access-Control-Allow-Headers": "Content-Type",
+          "Access-Control-Allow-Methods": "GET"
+        },
+        body: JSON.stringify({ error: "Document not found" })
+      };
+    }
+
+    // Return the document content
+    return {
+      statusCode: 200,
+      headers: {
+        "Content-Type": "application/json",
+        "Access-Control-Allow-Origin": "*",
+        "Access-Control-Allow-Headers": "Content-Type",
+        "Access-Control-Allow-Methods": "GET",
+        "Content-Disposition": `attachment; filename="${Item.title || 'document'}.txt"`
+      },
+      body: JSON.stringify({
+        document: Item,
+        content: Item.content || "",
+        title: Item.title || "document"
+      })
+    };
+  } catch (error: unknown) {
+    console.error("Error downloading document:", error);
+
+    return {
+      statusCode: 500,
+      headers: {
+        "Content-Type": "application/json",
+        "Access-Control-Allow-Origin": "*",
+        "Access-Control-Allow-Headers": "Content-Type",
+        "Access-Control-Allow-Methods": "GET"
+      },
+      body: JSON.stringify({ 
+        error: "Failed to download document", 
+        details: error instanceof Error ? error.message : 'Unknown error'
+      })
+    };
+  }
+};

amplify/functions/downloadDocument/resource.ts

@@ -0,0 +1,6 @@
+import { defineFunction } from "@aws-amplify/backend";
+
+export const downloadDocument = defineFunction({
+  name: "downloadDocument",
+  entry: "./handler.ts"
+});

amplify/functions/fetchDocuments/handler.ts

@@ -0,0 +1,52 @@
+import { APIGatewayProxyEvent, APIGatewayProxyResult } from 'aws-lambda';
+import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
+import { DynamoDBDocumentClient, ScanCommand } from "@aws-sdk/lib-dynamodb";
+
+const client = new DynamoDBClient({});
+const docClient = DynamoDBDocumentClient.from(client);
+
+// Get the DynamoDB table name from environment variables
+const tableName = process.env.DOCUMENT_TABLE_NAME || "Document-vnyciacn2nca3b6znjb4pulud4-NONE";
+
+export const handler = async (event: APIGatewayProxyEvent): Promise<APIGatewayProxyResult> => {
+  console.log("Event received:", JSON.stringify(event, null, 2));
+
+  try {
+    // Scan the DynamoDB table to get all documents
+    const scanParams = {
+      TableName: tableName,
+    };
+
+    const scanResponse = await docClient.send(new ScanCommand(scanParams));
+
+    // Return the results
+    return {
+      statusCode: 200,
+      headers: {
+        "Content-Type": "application/json",
+        "Access-Control-Allow-Origin": "*", // For CORS support
+        "Access-Control-Allow-Headers": "Content-Type",
+        "Access-Control-Allow-Methods": "GET"
+      },
+      body: JSON.stringify({
+        documents: scanResponse.Items || [],
+        count: scanResponse.Count || 0
+      })
+    };
+  } catch (error: unknown) {
+    console.error("Error fetching documents:", error);
+    return {
+      statusCode: 500,
+      headers: {
+        "Content-Type": "application/json",
+        "Access-Control-Allow-Origin": "*",
+        "Access-Control-Allow-Headers": "Content-Type",
+        "Access-Control-Allow-Methods": "GET"
+      },
+      body: JSON.stringify({ 
+        error: "Failed to fetch documents", 
+        details: error instanceof Error ? error.message : 'Unknown error' 
+      })
+    };
+  }
+};