Implement s3 profile modal (WIP)

web/src/core/adapters/s3Client/s3Client.ts

@@ -1,9 +1,10 @@
 import type { S3Client } from "core/ports/S3Client";
+import type { BucketPolicies } from "core/tools/bucketPolicies";
 import {
     getNewlyRequestedOrCachedTokenFactory,
     createSessionStorageTokenPersistence
 } from "core/tools/getNewlyRequestedOrCachedToken";
-import { assert, is, type Equals } from "tsafe/assert";
+import { assert, is, typeGuard, type Equals } from "tsafe";
 import type { Oidc } from "core/ports/Oidc";
 import { getS3UriKey, parseS3Uri } from "core/tools/S3Uri";
 import { exclude, id } from "tsafe";
@@ -219,6 +220,30 @@ export function createS3Client(
     })();
 
     const s3Client: S3Client = {
+        getUnsignedObjectHttpUrl: ({ s3Uri }) => {
+            const url = new URL(params.url);
+            const pathname = url.pathname.endsWith("/")
+                ? url.pathname.slice(0, -1)
+                : url.pathname;
+            const encodedKey = getS3UriKey(s3Uri)
+                .split("/")
+                .map(encodeURIComponent)
+                .join("/");
+
+            if (params.pathStyleAccess) {
+                url.pathname = `${pathname}/${encodeURIComponent(
+                    s3Uri.bucket
+                )}/${encodedKey}`;
+            } else {
+                url.hostname = `${s3Uri.bucket}.${url.hostname}`;
+                url.pathname = `${pathname}/${encodedKey}`;
+            }
+
+            url.search = "";
+            url.hash = "";
+
+            return url.href;
+        },
         getToken: async ({ doForceRenew }) => {
             const { getNewlyRequestedOrCachedToken, clearCachedToken } = await prApi;
 
@@ -433,7 +458,7 @@ export function createS3Client(
                 })
             );
         },
-        generateSignedDownloadUrl: async ({ s3Uri, validityDurationSecond }) => {
+        getSignedObjectHttpUrl: async ({ s3Uri, validityDurationSecond }) => {
             const { getAwsS3Client } = await prApi;
 
             const { awsS3Client } = await getAwsS3Client();
@@ -535,6 +560,97 @@ export function createS3Client(
                 }
             }
 
+            return { isSuccess: true };
+        },
+        getBucketPolicies: async ({ bucket }) => {
+            const { getAwsS3Client } = await prApi;
+
+            const { awsS3Client } = await getAwsS3Client();
+
+            const { GetBucketPolicyCommand, S3ServiceException } = await import(
+                "@aws-sdk/client-s3"
+            );
+
+            let policy: string | undefined;
+
+            try {
+                ({ Policy: policy } = await awsS3Client.send(
+                    new GetBucketPolicyCommand({
+                        Bucket: bucket
+                    })
+                ));
+            } catch (error) {
+                if (error instanceof S3ServiceException) {
+                    const httpStatusCode = error.$metadata?.httpStatusCode;
+
+                    if (httpStatusCode === 404) {
+                        console.log(
+                            [
+                                `Onyxia: The 404 here is fine`,
+                                `the bucket just doesn't have bucket policies yet.`
+                            ].join(" ")
+                        );
+                        return {
+                            Version: "2012-10-17",
+                            Statement: []
+                        };
+                    }
+
+                    if (
+                        httpStatusCode === 403 ||
+                        httpStatusCode === 405 ||
+                        httpStatusCode === 501 ||
+                        error.name === "NoSuchBucketPolicy" ||
+                        error.name === "NotImplemented" ||
+                        error.name === "NotSupported"
+                    ) {
+                        return undefined;
+                    }
+                }
+
+                throw error;
+            }
+
+            if (policy === undefined) {
+                return undefined;
+            }
+
+            const bucketPolicies: unknown = JSON.parse(policy);
+
+            assert(
+                typeGuard<BucketPolicies>(
+                    bucketPolicies,
+                    typeof bucketPolicies === "object" &&
+                        bucketPolicies !== null &&
+                        !Array.isArray(bucketPolicies)
+                )
+            );
+
+            return bucketPolicies;
+        },
+        putBucketPolicies: async ({ bucket, bucketPolicies }) => {
+            const { getAwsS3Client } = await prApi;
+
+            const { awsS3Client } = await getAwsS3Client();
+
+            const { PutBucketPolicyCommand } = await import("@aws-sdk/client-s3");
+
+            try {
+                await awsS3Client.send(
+                    new PutBucketPolicyCommand({
+                        Bucket: bucket,
+                        Policy: JSON.stringify(bucketPolicies)
+                    })
+                );
+            } catch (error) {
+                assert(is<Error>(error));
+
+                return {
+                    isSuccess: false,
+                    errorMessage: error.message
+                };
+            }
+
             return { isSuccess: true };
         }
     };

web/src/core/ports/S3Client.ts

@@ -1,5 +1,6 @@
 import type { S3Uri } from "core/tools/S3Uri";
 import type { NonPostableEvt } from "evt";
+import type { BucketPolicies } from "core/tools/bucketPolicies";
 
 export type S3Client = {
     getToken: (params: { doForceRenew: boolean }) => Promise<
@@ -31,11 +32,15 @@ export type S3Client = {
 
     deleteObject: (params: { s3Uri: S3Uri.NonTerminatedByDelimiter }) => Promise<void>;
 
-    generateSignedDownloadUrl: (params: {
+    getSignedObjectHttpUrl: (params: {
         s3Uri: S3Uri.NonTerminatedByDelimiter;
         validityDurationSecond: number;
     }) => Promise<string>;
 
+    getUnsignedObjectHttpUrl: (params: {
+        s3Uri: S3Uri.NonTerminatedByDelimiter;
+    }) => string;
+
     getObjectContent: (params: {
         s3Uri: S3Uri.NonTerminatedByDelimiter;
         range: `bytes=0-${number}` | undefined;
@@ -57,6 +62,15 @@ export type S3Client = {
               errorMessage: string;
           }
     >;
+
+    getBucketPolicies: (params: {
+        bucket: string;
+    }) => Promise<BucketPolicies | undefined>;
+
+    putBucketPolicies: (params: {
+        bucket: string;
+        bucketPolicies: BucketPolicies;
+    }) => Promise<{ isSuccess: true } | { isSuccess: false; errorMessage: string }>;
 };
 
 export namespace S3Client {