@scality/data-browser-library 1.0.0-preview.13 → 1.0.0-preview.16

package/dist/utils/s3Client.js

@@ -5,7 +5,7 @@ function extractProxyConfig(config) {
     if (config.useDevProxy && config.realS3Host && config.proxyPath) return {
         realS3Host: config.realS3Host,
         proxyBasePath: config.proxyPath,
-        proxyHost: config.proxyHost || "localhost",
+        proxyHost: config.proxyHost || 'localhost',
         proxyPort: config.proxyPort || 8084
     };
     const proxyConfig = S3ConfigurationFactory.createProxyConfiguration();

package/dist/utils/s3ConfigIdentifier.d.ts

@@ -0,0 +1,68 @@
+import { GetConfigFunction } from '../types';
+export declare const ANONYMOUS_S3_CONFIG_IDENTIFIER = "anonymous-s3-config";
+/**
+ * Hashes a session token using FNV-1a 64-bit algorithm for query cache isolation.
+ *
+ * Note: This is NOT a cryptographic hash - it's designed for collision resistance
+ * in the context of query key uniqueness, not security.
+ *
+ * The input is trimmed before hashing to ensure consistent results regardless of
+ * whitespace variations.
+ *
+ * @param sessionToken - AWS session token string to hash
+ * @returns A 16-character zero-padded hexadecimal string (64-bit hash)
+ */
+export declare const hashSessionToken: (sessionToken: string) => string;
+/**
+ * Normalizes a region string for consistent comparison.
+ *
+ * @param region - AWS region string
+ * @returns Normalized region (trimmed and lowercase)
+ */
+export declare const normalizeRegion: (region: string) => string;
+/**
+ * Normalizes an S3 endpoint URL for consistent comparison.
+ *
+ * Handles:
+ * - Protocol and hostname lowercasing
+ * - Default port removal (443 for HTTPS, 80 for HTTP)
+ * - Trailing slash removal from pathname
+ * - Query parameters and URL fragments are stripped
+ * - User credentials (username:password) are stripped
+ * - Invalid URL fallback to string normalization
+ *
+ * @param endpoint - S3 endpoint URL
+ * @returns Normalized endpoint string
+ */
+export declare const normalizeEndpoint: (endpoint: string) => string;
+/**
+ * Minimal configuration interface for computing S3 config identifiers.
+ *
+ * This is a documentation-focused subset interface that describes which fields
+ * are actually used by computeS3ConfigIdentifier. The function accepts any object
+ * with these optional properties, including the full S3BrowserConfig type.
+ *
+ * Only the fields listed here are used for generating the S3 config identifier.
+ * Other configuration fields (forcePathStyle, features, etc.) are ignored.
+ */
+export interface S3ConfigIdentifierConfig {
+    credentials?: {
+        roleArn?: string;
+        accessKeyId?: string;
+        secretAccessKey?: string;
+        sessionToken?: string;
+    };
+    region?: string;
+    endpoint?: string;
+}
+/**
+ * Computes a unique identifier for the current S3 configuration to isolate
+ * query caches between different S3 configurations.
+ *
+ * All inputs are normalized to prevent cache misses due to formatting differences.
+ *
+ * @param config - S3 configuration object
+ * @param fallbackIdentifier - Identifier to use when no config parts are available (default: ANONYMOUS_S3_CONFIG_IDENTIFIER)
+ * @returns An opaque identifier string (|| separated internally), or fallbackIdentifier if all parts are empty/missing
+ */
+export declare const computeS3ConfigIdentifier: (config: S3ConfigIdentifierConfig | ReturnType<GetConfigFunction>, fallbackIdentifier?: string) => string;

package/dist/utils/s3ConfigIdentifier.js

@@ -0,0 +1,55 @@
+const ANONYMOUS_S3_CONFIG_IDENTIFIER = 'anonymous-s3-config';
+const TEXT_ENCODER = new TextEncoder();
+const DEFAULT_PORTS = {
+    'https:': '443',
+    'http:': '80'
+};
+const IDENTIFIER_SEPARATOR = '||';
+const hashSessionToken = (sessionToken)=>{
+    const FNV_PRIME = 0x100000001b3n;
+    const FNV_OFFSET_BASIS = 0xcbf29ce484222325n;
+    const MASK_64 = 0xffffffffffffffffn;
+    let hash = FNV_OFFSET_BASIS;
+    const trimmed = sessionToken.trim();
+    const bytes = TEXT_ENCODER.encode(trimmed);
+    for (const byte of bytes){
+        hash ^= BigInt(byte);
+        hash = hash * FNV_PRIME & MASK_64;
+    }
+    return hash.toString(16).padStart(16, '0');
+};
+const normalizeRegion = (region)=>region.trim().toLowerCase();
+const normalizeEndpoint = (endpoint)=>{
+    const trimmed = endpoint.trim();
+    try {
+        const url = new URL(trimmed);
+        const protocol = url.protocol.toLowerCase();
+        const hostname = url.hostname.toLowerCase();
+        const isDefaultPort = '' === url.port || url.port === DEFAULT_PORTS[protocol];
+        const port = isDefaultPort ? '' : `:${url.port}`;
+        const pathname = url.pathname.replace(/\/+$/, '') || '';
+        return `${protocol}//${hostname}${port}${pathname}`;
+    } catch (error) {
+        return trimmed.replace(/\/+$/, '');
+    }
+};
+const computeS3ConfigIdentifier = (config, fallbackIdentifier = ANONYMOUS_S3_CONFIG_IDENTIFIER)=>{
+    const parts = [];
+    const roleArn = config?.credentials?.roleArn?.trim();
+    if (roleArn) parts.push(roleArn);
+    const accessKeyId = config?.credentials?.accessKeyId?.trim();
+    if (accessKeyId) {
+        parts.push(accessKeyId);
+        const sessionToken = config?.credentials?.sessionToken?.trim();
+        if (sessionToken) {
+            const hash = hashSessionToken(sessionToken);
+            parts.push(`session:${hash}`);
+        }
+    }
+    const region = config?.region?.trim();
+    if (region) parts.push(`region:${normalizeRegion(region)}`);
+    const endpoint = config?.endpoint?.trim();
+    if (endpoint) parts.push(`endpoint:${normalizeEndpoint(endpoint)}`);
+    return parts.length > 0 ? parts.join(IDENTIFIER_SEPARATOR) : fallbackIdentifier;
+};
+export { ANONYMOUS_S3_CONFIG_IDENTIFIER, computeS3ConfigIdentifier, hashSessionToken, normalizeEndpoint, normalizeRegion };

package/dist/utils/s3RuleUtils.d.ts

@@ -10,7 +10,7 @@ export declare const STATUS_OPTIONS: readonly [{
     readonly value: "Disabled";
     readonly label: "Disabled";
 }];
-export type FilterType = "none" | "prefix" | "tags" | "and";
+export type FilterType = 'none' | 'prefix' | 'tags' | 'and';
 /**
  * Filter data for S3 rules. All fields are present for form handling,
  * but only certain fields are used based on filterType.
@@ -28,18 +28,18 @@ export interface FilterData {
  * Each variant only includes the fields relevant to that filter type.
  */
 export type FilterSpec = {
-    type: "none";
+    type: 'none';
 } | {
-    type: "prefix";
+    type: 'prefix';
     prefix: string;
 } | {
-    type: "tags";
+    type: 'tags';
     tags: Array<{
         key: string;
         value: string;
     }>;
 } | {
-    type: "and";
+    type: 'and';
     prefix: string;
     tags: Array<{
         key: string;

package/dist/utils/s3RuleUtils.js

@@ -5,33 +5,33 @@ const AWS_RULE_LIMITS = {
 };
 const STATUS_OPTIONS = [
     {
-        value: "Enabled",
-        label: "Enabled"
+        value: 'Enabled',
+        label: 'Enabled'
     },
     {
-        value: "Disabled",
-        label: "Disabled"
+        value: 'Disabled',
+        label: 'Disabled'
     }
 ];
 function toFilterSpec(data) {
     switch(data.filterType){
-        case "none":
+        case 'none':
             return {
-                type: "none"
+                type: 'none'
             };
-        case "prefix":
+        case 'prefix':
             return {
-                type: "prefix",
+                type: 'prefix',
                 prefix: data.prefix
             };
-        case "tags":
+        case 'tags':
             return {
-                type: "tags",
+                type: 'tags',
                 tags: data.tags
             };
-        case "and":
+        case 'and':
             return {
-                type: "and",
+                type: 'and',
                 prefix: data.prefix,
                 tags: data.tags
             };
@@ -40,13 +40,13 @@ function toFilterSpec(data) {
 function buildS3Filter(data) {
     const spec = toFilterSpec(data);
     switch(spec.type){
-        case "none":
+        case 'none':
             return {};
-        case "prefix":
+        case 'prefix':
             return {
                 Prefix: spec.prefix
             };
-        case "tags":
+        case 'tags':
             if (0 === spec.tags.length) return {};
             if (1 === spec.tags.length) return {
                 Tag: {
@@ -62,9 +62,9 @@ function buildS3Filter(data) {
                         }))
                 }
             };
-        case "and":
+        case 'and':
             {
-                const hasPrefix = spec.prefix && "" !== spec.prefix.trim();
+                const hasPrefix = spec.prefix && '' !== spec.prefix.trim();
                 const hasTags = spec.tags.length > 0;
                 if (!hasTags && !hasPrefix) return {};
                 if (!hasTags && hasPrefix) return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scality/data-browser-library",
-  "version": "1.0.0-preview.13",
+  "version": "1.0.0-preview.16",
   "description": "A modular React component library for browsing S3 buckets and objects",
   "type": "module",
   "types": "./dist/index.d.ts",
@@ -57,7 +57,7 @@
     "identity-obj-proxy": "^3.0.0",
     "jest": "^30.0.5",
     "jest-environment-jsdom": "^30.0.5",
-    "msw": "^0.28.2",
+    "msw": "^2.12.3",
     "ts-jest": "^29.4.1"
   },
   "repository": {

package/dist/utils/useFeatures.d.ts

@@ -1 +0,0 @@
-export declare function useFeatures(feature: string): boolean | undefined;

package/dist/utils/useFeatures.js

@@ -1,7 +0,0 @@
-import { useDataBrowserContext } from "../components/index.js";
-function useFeatures(feature) {
-    const { getS3Config } = useDataBrowserContext();
-    const config = getS3Config();
-    return config?.features?.includes(feature);
-}
-export { useFeatures };