Backend changes

.github/workflows/api.yaml

@@ -0,0 +1,31 @@
+name: Deploy API Gateway
+
+on:
+  push:
+    paths:
+        - 'api/*'
+
+jobs:
+  deploy-api:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout repo
+        uses: actions/checkout@v3
+
+      - name: Set up Python
+        uses: actions/setup-python@v4
+        with:
+          python-version: '3.x'
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install boto3
+      - name: Run API deployment script
+        env:
+          AWS_ACCESS_KEY_ID: AKIAT5VEV4FHFQQJBZVX
+          AWS_SECRET_ACCESS_KEY: o56LCVEDcTPD8RgU2iWtz8SBklKa5DqQ6+nCYawf
+          AWS_REGION: us-east-1          # or your region
+        run: |
+          python3 api/deploy-api.py

.github/workflows/lambda.yaml

@@ -0,0 +1,95 @@
+name: Deploy Lambdas
+
+on:
+  push:
+    branches:
+      - main
+      - backend_changes
+
+env:
+  LAMBDA_DIR: backend
+  DEPLOY_BUCKET: hackathon-lambda-ap-ai-cyberark
+
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v3
+
+      - name: Set up Python
+        uses: actions/setup-python@v4
+        with:
+          python-version: '3.12'
+
+      - name: Install AWS CLI
+        run: pip install awscli
+
+      - name: Configure AWS credentials
+        uses: aws-actions/configure-aws-credentials@v2
+        with:
+          aws-access-key-id: AKIAT5VEV4FHFQQJBZVX
+          aws-secret-access-key: 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
+          aws-region: us-east-1
+
+      - name: Deploy Lambda Functions (No dependencies)
+        run: |
+          LAYER_ARN=$(aws lambda list-layer-versions \
+            --layer-name "my-python-layer" \
+            --query 'LayerVersions[0].LayerVersionArn' \
+            --output text)
+
+          echo "Using latest layer version: $LAYER_ARN"
+          for dir in "$LAMBDA_DIR"/*/; do
+            dir=${dir%/}
+            function_name=$(basename "$dir")
+            entry_point="$dir/${function_name}.py"
+
+            if [ ! -f "$entry_point" ]; then
+              echo "Skipping $function_name: $entry_point not found."
+              continue
+            fi
+
+            echo "Packaging Lambda: $function_name"
+
+            build_dir="/tmp/${function_name}_build"
+            zip_file="/tmp/${function_name}.zip"
+
+            rm -rf "$build_dir"
+            mkdir -p "$build_dir"
+
+            # Copy Lambda source file
+            cp -r "$dir"/* "$build_dir/"
+
+            # Copy all top-level shared files from backend (excluding directories and requirements.txt)
+            find "$LAMBDA_DIR" -maxdepth 1 -type f ! -name "requirements.txt" -exec cp {} "$build_dir/" \;
+
+            # Zip build directory
+            cd "$build_dir"
+            zip -r "$zip_file" . > /dev/null
+            cd -
+
+            # Upload zip to S3
+            aws s3 cp "$zip_file" "s3://${DEPLOY_BUCKET}/${function_name}.zip"
+
+            # Deploy Lambda
+            if aws lambda get-function --function-name "$function_name" > /dev/null 2>&1; then
+              echo "Updating Lambda: $function_name"
+              aws lambda update-function-code \
+                --function-name "$function_name" \
+                --s3-bucket "$DEPLOY_BUCKET" \
+                --s3-key "${function_name}.zip"
+            else
+              echo "Creating Lambda: $function_name"
+              aws lambda create-function \
+                --function-name "$function_name" \
+                --runtime python3.12 \
+                --role "arn:aws:iam::269854564686:role/hackathon-lambda-role" \
+                --handler "${function_name}.lambda_handler" \
+                --code S3Bucket="$DEPLOY_BUCKET",S3Key="${function_name}.zip" \
+                --timeout 900 \
+                --vpc-config SubnetIds=subnet-02e62e34308bb07d5,subnet-0534b99dd34e646f1,SecurityGroupIds=sg-0b9a6b812b30a1107 \
+                --layers "$LAYER_ARN"
+            fi
+          done

.github/workflows/layer.yaml

@@ -0,0 +1,88 @@
+name: Build Lambda Layer
+
+on:
+  push:
+    paths:
+      - 'backend/requirements.txt'
+  workflow_dispatch:
+
+jobs:
+  build-and-publish-layer:
+    runs-on: ubuntu-latest
+
+    env:
+      LAYER_NAME: my-python-layer
+      PYTHON_VERSION: python3.12
+      S3_KEY: layers/layer.zip
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.12'
+
+      - name: Install dependencies to python/
+        run: |
+          mkdir -p python
+          pip install -r backend/requirements.txt --platform manylinux2014_x86_64 --only-binary=:all: -t python/
+
+      - name: Clean up unnecessary files
+        run: |
+          find python/ -type d -name "__pycache__" -exec rm -rf {} +
+          find python/ -type d -name "tests" -exec rm -rf {} +
+          find python/ -type f -name "*.pyc" -delete
+
+      - name: Zip the layer
+        run: zip -r layer.zip python
+
+      - name: Configure AWS credentials
+        uses: aws-actions/configure-aws-credentials@v4
+        with:
+          aws-access-key-id: AKIAT5VEV4FHFQQJBZVX
+          aws-secret-access-key: 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
+          aws-region: us-east-1
+
+      - name: Upload zip to S3
+        run: |
+          aws s3 cp layer.zip s3://hackathon-lambda-ap-ai-cyberark/${{ env.S3_KEY }}
+
+      - name: Publish Lambda Layer from S3
+        run: |
+          aws lambda publish-layer-version \
+            --layer-name ${{ env.LAYER_NAME }} \
+            --description "Dependencies from backend/requirements.txt" \
+            --content S3Bucket=hackathon-lambda-ap-ai-cyberark,S3Key=${{ env.S3_KEY }} \
+            --compatible-runtimes ${{ env.PYTHON_VERSION }}
+
+      - name: Upload artifact (optional)
+        uses: actions/upload-artifact@v4
+        with:
+          name: lambda-layer
+          path: layer.zip
+
+      - name: Get latest layer version ARN
+        id: get-layer-version
+        run: |
+          LAYER_ARN=$(aws lambda list-layer-versions --layer-name ${{ env.LAYER_NAME }} \
+            --query 'LayerVersions[0].LayerVersionArn' --output text)
+          echo "layer_arn=$LAYER_ARN" >> "$GITHUB_OUTPUT"
+
+      - name: List functions using the layer
+        id: list-functions
+        run: |
+          FUNCTIONS=$(aws lambda list-functions --query \
+            "Functions[?Layers && contains(join(',', Layers[].Arn), '${{ env.LAYER_NAME }}')].FunctionName" \
+            --output text)
+          echo "functions=$FUNCTIONS" >> "$GITHUB_OUTPUT"
+
+      - name: Update functions to use latest layer version
+        run: |
+          for function in ${{ steps.list-functions.outputs.functions }}; do
+            echo "Updating $function..."
+            aws lambda update-function-configuration \
+              --function-name "$function" \
+              --layers ${{ steps.get-layer-version.outputs.layer_arn }}
+          done

.gitignore

@@ -193,3 +193,6 @@ cython_debug/
 .cursorignore
 .cursorindexingignore
 .DS_Store
+
+node_modules
+package-lock.json

amplify.py

@@ -11,7 +11,6 @@
 branch = sys.argv[2]
 repo_owner, repo_name = repo_full.split('/')
 app_name = f"amplify-{repo_name}"
-
 client = boto3.client('amplify','us-east-1')
 print(GITHUB_PAT)
 

api/deploy-api.py

@@ -0,0 +1,144 @@
+import boto3
+import json
+import os
+
+REGION = "us-east-1"
+STAGE = "prod"
+ACCOUNT_ID = "269854564686"
+
+apigateway = boto3.client("apigateway", region_name=REGION)
+lambda_client = boto3.client("lambda", region_name=REGION)
+
+def get_or_create_api(api_name):
+    apis = apigateway.get_rest_apis()["items"]
+    for api in apis:
+        if api["name"] == api_name:
+            print(f"Found API: {api_name}")
+            return api["id"]
+
+    print(f"Creating API: {api_name}")
+    response = apigateway.create_rest_api(name=api_name)
+    return response["id"]
+
+def get_or_create_resource(api_id, full_path):
+    # Normalize and split nested path: "users/{userId}" => ["users", "{userId}"]
+    parts = [p for p in full_path.strip("/").split("/") if p]
+    resources = apigateway.get_resources(restApiId=api_id)["items"]
+
+    # Build a path-to-id map
+    path_map = {res["path"]: res["id"] for res in resources}
+    parent_path = ""
+    parent_id = path_map["/"]  # root path
+
+    for part in parts:
+        current_path = f"{parent_path}/{part}" if parent_path else f"/{part}"
+        if current_path in path_map:
+            parent_id = path_map[current_path]
+        else:
+            print(f"Creating resource: {current_path}")
+            response = apigateway.create_resource(
+                restApiId=api_id,
+                parentId=parent_id,
+                pathPart=part
+            )
+            parent_id = response["id"]
+            path_map[current_path] = parent_id
+        parent_path = current_path
+
+    return parent_id
+
+
+def method_exists(api_id, resource_id, http_method):
+    try:
+        apigateway.get_method(
+            restApiId=api_id,
+            resourceId=resource_id,
+            httpMethod=http_method
+        )
+        return True
+    except apigateway.exceptions.NotFoundException:
+        return False
+
+def add_lambda_permission(lambda_name, api_id, method, path):
+    statement_id = f"{lambda_name.lower()}-{method.lower()}"
+    try:
+        lambda_client.add_permission(
+            FunctionName=lambda_name,
+            StatementId=statement_id,
+            Action="lambda:InvokeFunction",
+            Principal="apigateway.amazonaws.com",
+            SourceArn=f"arn:aws:execute-api:{REGION}:{ACCOUNT_ID}:{api_id}/*/{method}/{path}"
+        )
+        print(f"Added permission to Lambda {lambda_name} for method {method} /{path}")
+    except lambda_client.exceptions.ResourceConflictException:
+        # Permission already exists
+        print(f"Permission already exists for Lambda {lambda_name} and method {method} /{path}")
+
+def setup_method(api_id, resource_id, method_def, path):
+    method = method_def["httpMethod"].upper()
+    lambda_name = method_def["lambdaFunctionName"]
+    auth_type = method_def.get("authorizationType", "NONE")
+    lambda_arn = f"arn:aws:lambda:{REGION}:{ACCOUNT_ID}:function:{lambda_name}"
+
+    if method_exists(api_id, resource_id, method):
+        print(f"Method {method} already exists for /{path}, skipping method creation.")
+    else:
+        print(f"Creating method {method} for /{path}")
+        apigateway.put_method(
+            restApiId=api_id,
+            resourceId=resource_id,
+            httpMethod=method,
+            authorizationType=auth_type
+        )
+
+    print(f"Setting integration for {method} /{path}")
+    apigateway.put_integration(
+        restApiId=api_id,
+        resourceId=resource_id,
+        httpMethod=method,
+        type="AWS_PROXY",
+        integrationHttpMethod="POST",
+        uri=f"arn:aws:apigateway:{REGION}:lambda:path/2015-03-31/functions/{lambda_arn}/invocations"
+    )
+
+    add_lambda_permission(lambda_name, api_id, method, path)
+
+def deploy_api(api_id):
+    print(f"Deploying API {api_id} to stage: {STAGE}")
+    apigateway.create_deployment(
+        restApiId=api_id,
+        stageName=STAGE
+    )
+
+def main():
+    # Use script folder as working directory to find JSON files
+    script_dir = os.path.dirname(os.path.abspath(__file__))
+
+    deploy_apis = set()
+
+    # Loop all JSON files in current folder
+    for file in os.listdir(script_dir):
+        if not file.endswith(".json"):
+            continue
+
+        json_path = os.path.join(script_dir, file)
+        with open(json_path) as f:
+            config = json.load(f)
+
+        api_name = config["apiName"]
+        resource_path = config["resourcePath"]
+        method_def = config["method"]
+        should_deploy = config.get("deploy", False)
+
+        api_id = get_or_create_api(api_name)
+        resource_id = get_or_create_resource(api_id, resource_path)
+        setup_method(api_id, resource_id, method_def, resource_path)
+
+        if should_deploy:
+            deploy_apis.add(api_id)
+
+    for api_id in deploy_apis:
+        deploy_api(api_id)
+
+if __name__ == "__main__":
+    main()

api/get-value.json

@@ -0,0 +1,10 @@
+{
+  "apiName": "hackathon",
+  "resourcePath": "get-value",
+  "method": {
+    "httpMethod": "GET",
+    "authorizationType": "NONE",
+    "lambdaFunctionName": "Submit"
+  },
+  "deploy": true
+}