S3 Features Overhaul 🚀

.vscode/mcp.json

@@ -0,0 +1,9 @@
+{
+	"servers": {
+		"figma": {
+			"url": "http://127.0.0.1:3845/mcp",
+			"type": "http"
+		}
+	},
+	"inputs": []
+}

web/.env

@@ -893,3 +893,4 @@ OIDC_DISABLE_DPOP=false
 
 # Can be "auto", "iframe" or "full page redirect"
 OIDC_SESSION_RESTORATION_METHOD=auto
+

web/package.json

@@ -54,7 +54,7 @@
         "async-mutex": "^0.5.0",
         "axios": "^1.9.0",
         "bytes": "^3.1.2",
-        "clean-architecture": "^6.0.3",
+        "clean-architecture": "^6.1.0",
         "codemirror": "6.0.1",
         "codemirror-json-schema": "0.7.9",
         "compare-versions": "^6.1.1",
@@ -70,15 +70,15 @@
         "minimal-polyfills": "^2.2.3",
         "mui-icons-material-lazy": "^1.0.4",
         "oidc-spa": "^10.0.4",
-        "onyxia-ui": "^6.7.8",
+        "onyxia-ui": "^6.10.0",
         "pathe": "^2.0.3",
         "powerhooks": "^2.0.1",
         "react": "^18.3.1",
         "react-code-blocks": "^0.1.6",
         "react-dom": "^18.3.1",
         "run-exclusive": "^2.2.19",
         "screen-scaler": "^2.0.0",
-        "tsafe": "^1.8.5",
+        "tsafe": "^1.8.12",
         "tss-react": "^4.9.18",
         "type-route": "1.1.0",
         "xterm": "^5.3.0",

web/spec.md

@@ -0,0 +1,57 @@
+Before:
+
+```js
+{
+    workingDirectory: {
+        bucketMode: "multi",
+        bucketNamePrefix: "",
+        bucketNamePrefixGroup: "projet-"
+    },
+    bookmarkedDirectories: [
+        {
+            fullPath: "donnees-insee/diffusion/",
+            title: {
+                fr: "Données de diffusion",
+                en: "Dissemination Data"
+            },
+            description: {
+                fr: "Bucket public destiné à la diffusion de données",
+                en: "Public bucket intended for data dissemination"
+            }
+        }
+    ]
+}
+```
+
+After:
+
+```js
+{
+    bookmarkedDirectories: [
+        {
+            fullPath: "$1/",
+            title: "Personal",
+            description: "Personal Bucket",
+            claimName: "preferred_username"
+        },
+        {
+            fullPath: "projet-$1/",
+            title: "Group $1",
+            description: "Shared bucket among members of project $1",
+            claimName: "groups",
+            excludedClaimPattern: "^USER_ONYXIA$"
+        },
+        {
+            fullPath: "donnees-insee/diffusion/",
+            title: {
+                fr: "Données de diffusion",
+                en: "Dissemination Data"
+            },
+            description: {
+                fr: "Bucket public destiné à la diffusion de données",
+                en: "Public bucket intended for data dissemination"
+            }
+        }
+    ];
+}
+```

web/src/core/adapters/onyxiaApi/ApiTypes.ts

@@ -83,23 +83,33 @@
             };
             data?: {
                 S3?: ArrayOrNot<{
+                    profileName?: string;
                     URL: string;
                     pathStyleAccess?: true;
 
                     region?: string;
                     sts?: {
                         URL?: string;
                         durationSeconds?: number;
-                        role:
-                            | {
-                                  roleARN: string;
-                                  roleSessionName: string;
-                              }
-                            | undefined;
+                        role?: ArrayOrNot<
+                            {
+                                roleARN: string;
+                                roleSessionName: string;
+                                profileName: string;
+                            } & (
+                                | { claimName?: undefined }
+                                | {
+                                      claimName: string;
+                                      includedClaimPattern?: string;
+                                      excludedClaimPattern?: string;
+                                  }
+                            )
+                        >;
                         oidcConfiguration?: Partial<ApiTypes.OidcConfiguration>;
                     };
 
                     /** Ok to be undefined only if sts is undefined */
+                    // NOTE: Remove in next major
                     workingDirectory?:
                         | {
                               bucketMode: "shared";
@@ -115,14 +125,15 @@
                     bookmarkedDirectories?: ({
                         fullPath: string;
                         title: LocalizedString;
-                        description: LocalizedString | undefined;
-                        tags: LocalizedString[] | undefined;
+                        description?: LocalizedString;
+                        tags?: LocalizedString[];
+                        forProfileName?: string | string[];
                     } & (
-                        | { claimName: undefined }
+                        | { claimName?: undefined }
                         | {
                               claimName: string;
-                              includedClaimPattern: string;
-                              excludedClaimPattern: string;
+                              includedClaimPattern?: string;
+                              excludedClaimPattern?: string;
                           }
                     ))[];
                 }>;

web/src/core/adapters/onyxiaApi/onyxiaApi.ts

@@ -232,7 +232,141 @@
                                     return [value];
                                 })();
 
-                                const s3ConfigCreationFormDefaults: DeploymentRegion["s3ConfigCreationFormDefaults"] =
+                                const s3Profiles: DeploymentRegion.S3Profile[] =
+                                    s3Configs_api
+                                        .filter(
+                                            s3Configs_api =>
+                                                s3Configs_api.sts !== undefined
+                                        )
+                                        .map(
+                                            (
+                                                s3Config_api
+                                            ): DeploymentRegion.S3Profile => {
+                                                return {
+                                                    profileName: s3Config_api.profileName,
+                                                    url: s3Config_api.URL,
+                                                    pathStyleAccess:
+                                                        s3Config_api.pathStyleAccess ??
+                                                        true,
+                                                    region: s3Config_api.region,
+                                                    sts: (() => {
+                                                        const sts_api = s3Config_api.sts;
+
+                                                        assert(sts_api !== undefined);
+
+                                                        return {
+                                                            url: sts_api.URL,
+                                                            durationSeconds:
+                                                                sts_api.durationSeconds,
+                                                            roles: (() => {
+                                                                if (
+                                                                    sts_api.role ===
+                                                                    undefined
+                                                                ) {
+                                                                    return [];
+                                                                }
+
+                                                                const rolesArray =
+                                                                    sts_api.role instanceof
+                                                                    Array
+                                                                        ? sts_api.role
+                                                                        : [sts_api.role];
+
+                                                                return rolesArray.map(
+                                                                    (
+                                                                        role_api
+                                                                    ): DeploymentRegion.S3Profile.StsRole => ({
+                                                                        roleARN:
+                                                                            role_api.roleARN,
+                                                                        roleSessionName:
+                                                                            role_api.roleSessionName,
+                                                                        profileName:
+                                                                            role_api.profileName,
+                                                                        ...(role_api.claimName ===
+                                                                        undefined
+                                                                            ? {
+                                                                                  claimName:
+                                                                                      undefined
+                                                                              }
+                                                                            : {
+                                                                                  claimName:
+                                                                                      role_api.claimName,
+                                                                                  includedClaimPattern:
+                                                                                      role_api.includedClaimPattern,
+                                                                                  excludedClaimPattern:
+                                                                                      role_api.excludedClaimPattern
+                                                                              })
+                                                                    })
+                                                                );
+                                                            })(),
+                                                            oidcParams:
+                                                                apiTypesOidcConfigurationToOidcParams_Partial(
+                                                                    sts_api.oidcConfiguration
+                                                                )
+                                                        } as any;
+                                                    })(),
+                                                    bookmarks: (
+                                                        s3Config_api.bookmarkedDirectories ??
+                                                        []
+                                                    ).map(
+                                                        (
+                                                            bookmarkedDirectory_api
+                                                        ): DeploymentRegion.S3Profile.Bookmark => {
+                                                            return id<DeploymentRegion.S3Profile.Bookmark>(
+                                                                {
+                                                                    s3UriStr_templated: `s3://${bookmarkedDirectory_api.fullPath}`,
+                                                                    title: bookmarkedDirectory_api.title,
+                                                                    description:
+                                                                        bookmarkedDirectory_api.description,
+                                                                    tags:
+                                                                        bookmarkedDirectory_api.tags ??
+                                                                        [],
+                                                                    forProfileNames:
+                                                                        (() => {
+                                                                            const v =
+                                                                                bookmarkedDirectory_api.forProfileName;
+
+                                                                            if (
+                                                                                v ===
+                                                                                undefined
+                                                                            ) {
+                                                                                return [];
+                                                                            }
+
+                                                                            if (
+                                                                                typeof v ===
+                                                                                "string"
+                                                                            ) {
+                                                                                return [
+                                                                                    v
+                                                                                ];
+                                                                            }
+
+                                                                            return v;
+                                                                        })(),
+                                                                    ...(bookmarkedDirectory_api.claimName ===
+                                                                    undefined
+                                                                        ? {
+                                                                              claimName:
+                                                                                  undefined
+                                                                          }
+                                                                        : {
+                                                                              claimName:
+                                                                                  bookmarkedDirectory_api.claimName,
+                                                                              includedClaimPattern:
+                                                                                  bookmarkedDirectory_api.includedClaimPattern,
+                                                                              excludedClaimPattern:
+                                                                                  bookmarkedDirectory_api.excludedClaimPattern
+                                                                          })
+                                                                }
+                                                            );
+                                                        }
+                                                    )
+                                                };
+                                            }
+                                        );
+
+                                const s3Profiles_defaultValuesOfCreationForm: DeploymentRegion["s3Profiles_defaultValuesOfCreationForm"] =
                                     (() => {
                                         const s3Config_api = (() => {
                                             config_without_sts: {
@@ -265,54 +399,13 @@
                                             url: s3Config_api.URL,
                                             pathStyleAccess:
                                                 s3Config_api.pathStyleAccess ?? true,
-                                            region: s3Config_api.region,
-                                            workingDirectory:
-                                                s3Config_api.workingDirectory
+                                            region: s3Config_api.region
                                         };
                                     })();
 
-                                const s3Configs: DeploymentRegion["s3Configs"] =
-                                    s3Configs_api
-                                        .map(({ sts, workingDirectory, ...rest }) => {
-                                            if (sts === undefined) {
-                                                return undefined;
-                                            }
-                                            assert(
-                                                workingDirectory !== undefined,
-                                                "If region.data.S3.sts is not undefined workingDirectory must be specified"
-                                            );
-
-                                            return {
-                                                sts,
-                                                workingDirectory,
-                                                ...rest
-                                            };
-                                        })
-                                        .filter(exclude(undefined))
-                                        .map(s3Config_api => ({
-                                            url: s3Config_api.URL,
-                                            pathStyleAccess:
-                                                s3Config_api.pathStyleAccess ?? true,
-                                            region: s3Config_api.region,
-                                            sts: {
-                                                url: s3Config_api.sts.URL,
-                                                durationSeconds:
-                                                    s3Config_api.sts.durationSeconds,
-                                                role: s3Config_api.sts.role,
-                                                oidcParams:
-                                                    apiTypesOidcConfigurationToOidcParams_Partial(
-                                                        s3Config_api.sts.oidcConfiguration
-                                                    )
-                                            },
-                                            workingDirectory:
-                                                s3Config_api.workingDirectory,
-                                            bookmarkedDirectories:
-                                                s3Config_api.bookmarkedDirectories ?? []
-                                        }));
-
                                 return {
-                                    s3Configs,
-                                    s3ConfigCreationFormDefaults
+                                    s3Profiles,
+                                    s3Profiles_defaultValuesOfCreationForm
                                 };
                             })(),
                             allowedURIPatternForUserDefinedInitScript: