@scality/data-browser-library 1.0.0-preview.8 → 1.0.1

package/dist/utils/proxyMiddleware.d.ts

@@ -1,18 +1,37 @@
-import { Pluggable } from "@aws-sdk/types";
-interface ProxyConfig {
-    realS3Host: string;
-    proxyBasePath: string;
-    proxyHost: string;
-    proxyPort: number;
-}
+import type { ServiceInputTypes, ServiceOutputTypes } from '@aws-sdk/client-s3';
+import type { Pluggable } from '@aws-sdk/types';
+import type { ProxyConfiguration } from '../config/types';
+/**
+ * Resolves proxy endpoint to a full URL
+ *
+ * Supported formats:
+ * - "origin" → window.location.origin
+ * - "/path" → window.location.origin + "/path"
+ * - "http://..." → unchanged
+ *
+ * @param endpoint Proxy endpoint string
+ * @returns Resolved full URL
+ */
+export declare function resolveProxyEndpoint(endpoint: string): string;
+/**
+ * Parses endpoint URL and validates basic security requirements
+ *
+ * @param endpoint Endpoint URL string
+ * @returns Parsed endpoint components
+ */
+export declare function parseEndpoint(endpoint: string): {
+    hostname: string;
+    port: number;
+    protocol: string;
+    pathname: string;
+};
 /**
  * Creates a two-stage proxy middleware for AWS SDK v3
  *
- * This middleware enables proper S3 request signing through a development proxy:
- * 1. Pre-signing: Modifies requests to use real S3 host for correct signature calculation
- * 2. Post-signing: Routes signed requests through proxy to avoid CORS issues
+ * Stage 1: Pre-signing - Replace proxy host with target S3 for signature calculation
+ * Stage 2: Post-signing - Route signed request back through proxy
  *
- * @param config Proxy configuration from build-time constants
+ * @param config Proxy configuration with target S3 endpoint and proxy endpoint
+ * @returns AWS SDK v3 pluggable middleware
  */
-export declare const createProxyMiddleware: (config: ProxyConfig) => Pluggable<any, any>;
-export {};
+export declare const createProxyMiddleware: (config: ProxyConfiguration) => Pluggable<ServiceInputTypes, ServiceOutputTypes>;

package/dist/utils/proxyMiddleware.js

@@ -1,56 +1,110 @@
 import { HttpRequest } from "@aws-sdk/protocol-http";
-const createProxyMiddleware = (config)=>({
+const ALLOWED_PROTOCOLS = [
+    'http:',
+    'https:'
+];
+function resolveProxyEndpoint(endpoint) {
+    if (!endpoint || 'string' != typeof endpoint) throw new Error('Proxy endpoint must be a non-empty string');
+    const trimmed = endpoint.trim();
+    if (!trimmed) throw new Error('Proxy endpoint cannot be empty');
+    if ('origin' === trimmed) {
+        if ('undefined' == typeof window || !window?.location?.origin) throw new Error('Cannot use "origin" keyword outside browser environment');
+        const origin = window.location.origin;
+        if (!origin.startsWith('http://') && !origin.startsWith('https://')) throw new Error(`Invalid origin protocol: ${origin}`);
+        return origin;
+    }
+    if (trimmed.startsWith('/')) {
+        if ('undefined' == typeof window || !window?.location?.origin) throw new Error('Cannot resolve relative path outside browser environment');
+        const origin = window.location.origin;
+        if (!origin.startsWith('http://') && !origin.startsWith('https://')) throw new Error(`Invalid origin protocol: ${origin}`);
+        return origin + trimmed;
+    }
+    try {
+        new URL(trimmed);
+    } catch (e) {
+        throw new Error(`Invalid proxy endpoint URL: ${trimmed}`);
+    }
+    return trimmed;
+}
+function parseEndpoint(endpoint) {
+    let url;
+    let prepared = endpoint;
+    try {
+        if (!endpoint.includes('://')) prepared = `http://${endpoint}`;
+        url = new URL(prepared);
+        if (!ALLOWED_PROTOCOLS.includes(url.protocol)) throw new Error(`Protocol "${url.protocol}" not allowed. Use http: or https:`);
+        if (url.username || url.password) throw new Error('Embedded credentials in URLs are not allowed');
+        if (!url.hostname) throw new Error('Hostname cannot be empty');
+    } catch (error) {
+        if (error instanceof Error && error.message.includes('not allowed')) throw error;
+        if (error instanceof TypeError) throw new Error(`Invalid endpoint URL: ${endpoint}`);
+        throw error;
+    }
+    return {
+        hostname: url.hostname,
+        port: url.port ? parseInt(url.port, 10) : 'https:' === url.protocol ? 443 : 80,
+        protocol: url.protocol,
+        pathname: '/' === url.pathname ? '' : url.pathname
+    };
+}
+const createProxyMiddleware = (config)=>{
+    if (!config.target) throw new Error('ProxyConfiguration.target is required');
+    const resolvedProxyEndpoint = resolveProxyEndpoint(config.endpoint);
+    const target = parseEndpoint(config.target);
+    const proxy = parseEndpoint(resolvedProxyEndpoint);
+    return {
         applyToStack: (clientStack)=>{
             const preSigningMiddleware = (next)=>async (args)=>{
                     const { request } = args;
-                    if (HttpRequest.isInstance(request) && request.hostname === config.proxyHost) {
-                        const originalQuery = request.query || {};
-                        if (request.path.startsWith(config.proxyBasePath)) {
-                            request.path = request.path.replace(config.proxyBasePath, '');
-                            if (!request.path.startsWith('/')) request.path = '/' + request.path;
+                    if (HttpRequest.isInstance(request) && request.hostname === proxy.hostname) {
+                        const originalQuery = request.query ? {
+                            ...request.query
+                        } : {};
+                        if (proxy.pathname && '/' !== proxy.pathname) {
+                            const normalizedProxyPath = proxy.pathname.toLowerCase();
+                            const normalizedRequestPath = request.path.toLowerCase();
+                            if (normalizedRequestPath.startsWith(normalizedProxyPath)) {
+                                const prefixLength = proxy.pathname.length;
+                                request.path = request.path.substring(prefixLength);
+                                if (request.path) {
+                                    if (!request.path.startsWith('/')) request.path = '/' + request.path;
+                                } else request.path = '/';
+                            }
                         }
-                        request.hostname = config.realS3Host;
-                        request.port = 443;
-                        request.protocol = 'https:';
-                        request.headers.host = config.realS3Host;
+                        request.hostname = target.hostname;
+                        request.port = target.port;
+                        request.protocol = target.protocol;
+                        request.headers.host = target.port && 80 !== target.port && 443 !== target.port ? `${target.hostname}:${target.port}` : target.hostname;
                         request.query = originalQuery;
-                        console.log('Pre-signing: Modified for real S3 signing', {
-                            path: request.path,
-                            host: request.hostname,
-                            query: request.query
-                        });
                     }
                     return next(args);
                 };
             const postSigningMiddleware = (next)=>async (args)=>{
                     const { request } = args;
-                    if (HttpRequest.isInstance(request) && request.hostname === config.realS3Host) {
-                        const queryParams = request.query || {};
-                        request.hostname = config.proxyHost;
-                        request.port = config.proxyPort;
-                        request.protocol = 'http:';
-                        request.path = config.proxyBasePath + request.path;
-                        request.headers.host = `${config.proxyHost}:${config.proxyPort}`;
+                    if (HttpRequest.isInstance(request) && request.hostname === target.hostname) {
+                        const queryParams = request.query ? {
+                            ...request.query
+                        } : {};
+                        request.hostname = proxy.hostname;
+                        request.port = proxy.port;
+                        request.protocol = proxy.protocol;
+                        request.path = '' === proxy.pathname || '/' === proxy.pathname ? request.path : proxy.pathname + request.path;
+                        request.headers.host = proxy.port && 80 !== proxy.port && 443 !== proxy.port ? `${proxy.hostname}:${proxy.port}` : proxy.hostname;
                         request.query = queryParams;
-                        console.log('Post-signing: Routed to proxy', {
-                            host: request.hostname,
-                            path: request.path,
-                            query: request.query,
-                            hasAuth: !!request.headers.authorization
-                        });
                     }
                     return next(args);
                 };
             clientStack.add(preSigningMiddleware, {
-                step: "build",
-                name: "proxyPreSigningMiddleware",
-                priority: "high"
+                step: 'build',
+                name: 'proxyPreSigningMiddleware',
+                priority: 'high'
             });
             clientStack.add(postSigningMiddleware, {
-                step: "finalizeRequest",
-                name: "proxyPostSigningMiddleware",
-                priority: "high"
+                step: 'finalizeRequest',
+                name: 'proxyPostSigningMiddleware',
+                priority: 'high'
             });
         }
-    });
-export { createProxyMiddleware };
+    };
+};
+export { createProxyMiddleware, parseEndpoint, resolveProxyEndpoint };

package/dist/utils/s3Client.d.ts

@@ -1,5 +1,15 @@
-import { S3Client } from "@aws-sdk/client-s3";
-import { S3BrowserConfig, S3Credentials } from "../types";
-export declare const createS3Client: (config: S3BrowserConfig & {
+import { S3Client } from '@aws-sdk/client-s3';
+import type { S3BrowserConfig, S3Credentials } from '../types';
+/**
+ * S3Client configuration with credentials
+ */
+export interface S3ClientConfigWithProxy extends S3BrowserConfig {
     credentials: S3Credentials;
-}) => S3Client;
+}
+/**
+ * Create S3 client with optional proxy middleware
+ *
+ * @param config - S3 configuration with credentials and optional proxy config
+ * @returns Configured S3Client instance
+ */
+export declare const createS3Client: (config: S3ClientConfigWithProxy) => S3Client;

package/dist/utils/s3Client.js

@@ -1,36 +1,15 @@
 import { S3Client } from "@aws-sdk/client-s3";
-import { createProxyMiddleware } from "./proxyMiddleware.js";
-import { S3ConfigurationFactory } from "../config/factory.js";
-function extractProxyConfig(config) {
-    if (config.useDevProxy && config.realS3Host && config.proxyPath) return {
-        realS3Host: config.realS3Host,
-        proxyBasePath: config.proxyPath,
-        proxyHost: config.proxyHost || "localhost",
-        proxyPort: config.proxyPort || 8084
-    };
-    const proxyConfig = S3ConfigurationFactory.createProxyConfiguration();
-    if (proxyConfig.useProxy && proxyConfig.proxyConfig) return {
-        realS3Host: proxyConfig.proxyConfig.realHost,
-        proxyBasePath: proxyConfig.proxyConfig.proxyBasePath,
-        proxyHost: proxyConfig.proxyConfig.proxyHost,
-        proxyPort: proxyConfig.proxyConfig.proxyPort
-    };
-    return null;
-}
+import { createProxyMiddleware, resolveProxyEndpoint } from "./proxyMiddleware.js";
 const createS3Client = (config)=>{
+    if (config.proxy?.enabled && !config.proxy.target) throw new Error('Proxy configuration error: "target" is required when proxy is enabled');
+    const clientEndpoint = config.proxy?.enabled ? resolveProxyEndpoint(config.proxy.endpoint) : config.endpoint;
     const client = new S3Client({
-        ...config,
+        endpoint: clientEndpoint,
         credentials: config.credentials,
         forcePathStyle: config.forcePathStyle ?? true,
         region: config.region
     });
-    const proxyConfig = extractProxyConfig(config);
-    if (proxyConfig) client.middlewareStack.use(createProxyMiddleware({
-        realS3Host: proxyConfig.realS3Host,
-        proxyBasePath: proxyConfig.proxyBasePath,
-        proxyHost: proxyConfig.proxyHost,
-        proxyPort: proxyConfig.proxyPort
-    }));
+    if (config.proxy?.enabled) client.middlewareStack.use(createProxyMiddleware(config.proxy));
     return client;
 };
 export { createS3Client };

package/dist/utils/s3ConfigIdentifier.d.ts

@@ -0,0 +1,79 @@
+import type { 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 interface describes which fields are used by `computeS3ConfigIdentifier`.
+ * The function accepts any object with these optional properties, including the
+ * full S3BrowserConfig type.
+ *
+ * ## Cache Key Resolution Priority
+ *
+ * 1. `cacheKey` (top-level) - Explicit cache identity, highest priority
+ * 2. `accessKeyId` + `sessionToken` - Fallback for direct credentials
+ *
+ * When `cacheKey` is provided, `accessKeyId` and `sessionToken` are ignored
+ * for cache key generation. This prevents unnecessary cache invalidation when
+ * credentials refresh but the logical identity remains the same.
+ */
+export interface S3ConfigIdentifierConfig {
+    /**
+     * Explicit cache identity. When provided, takes priority over credentials.
+     * Use this when credentials change frequently (e.g., token refresh) but
+     * represent the same logical identity.
+     */
+    cacheKey?: string;
+    credentials?: {
+        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,57 @@
+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 cacheKey = config?.cacheKey?.trim();
+    if (cacheKey) parts.push(cacheKey);
+    else {
+        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

@@ -0,0 +1,53 @@
+export declare const AWS_RULE_LIMITS: {
+    RULE_ID_MAX_LENGTH: number;
+    TAG_KEY_MAX_LENGTH: number;
+    TAG_VALUE_MAX_LENGTH: number;
+};
+export declare const STATUS_OPTIONS: readonly [{
+    readonly value: "Enabled";
+    readonly label: "Enabled";
+}, {
+    readonly value: "Disabled";
+    readonly label: "Disabled";
+}];
+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.
+ */
+export interface FilterData {
+    filterType: FilterType;
+    prefix: string;
+    tags: Array<{
+        key: string;
+        value: string;
+    }>;
+}
+/**
+ * Type-safe filter specification for S3 rule building.
+ * Each variant only includes the fields relevant to that filter type.
+ */
+export type FilterSpec = {
+    type: 'none';
+} | {
+    type: 'prefix';
+    prefix: string;
+} | {
+    type: 'tags';
+    tags: Array<{
+        key: string;
+        value: string;
+    }>;
+} | {
+    type: 'and';
+    prefix: string;
+    tags: Array<{
+        key: string;
+        value: string;
+    }>;
+};
+/**
+ * Converts form FilterData to type-safe FilterSpec.
+ */
+export declare function toFilterSpec(data: FilterData): FilterSpec;
+export declare function buildS3Filter(data: FilterData): Record<string, unknown>;

package/dist/utils/s3RuleUtils.js

@@ -0,0 +1,101 @@
+const AWS_RULE_LIMITS = {
+    RULE_ID_MAX_LENGTH: 255,
+    TAG_KEY_MAX_LENGTH: 128,
+    TAG_VALUE_MAX_LENGTH: 256
+};
+const STATUS_OPTIONS = [
+    {
+        value: 'Enabled',
+        label: 'Enabled'
+    },
+    {
+        value: 'Disabled',
+        label: 'Disabled'
+    }
+];
+function toFilterSpec(data) {
+    switch(data.filterType){
+        case 'none':
+            return {
+                type: 'none'
+            };
+        case 'prefix':
+            return {
+                type: 'prefix',
+                prefix: data.prefix
+            };
+        case 'tags':
+            return {
+                type: 'tags',
+                tags: data.tags
+            };
+        case 'and':
+            return {
+                type: 'and',
+                prefix: data.prefix,
+                tags: data.tags
+            };
+    }
+}
+function buildS3Filter(data) {
+    const spec = toFilterSpec(data);
+    switch(spec.type){
+        case 'none':
+            return {};
+        case 'prefix':
+            return {
+                Prefix: spec.prefix
+            };
+        case 'tags':
+            if (0 === spec.tags.length) return {};
+            if (1 === spec.tags.length) return {
+                Tag: {
+                    Key: spec.tags[0].key,
+                    Value: spec.tags[0].value
+                }
+            };
+            return {
+                And: {
+                    Tags: spec.tags.map((tag)=>({
+                            Key: tag.key,
+                            Value: tag.value
+                        }))
+                }
+            };
+        case 'and':
+            {
+                const hasPrefix = spec.prefix && '' !== spec.prefix.trim();
+                const hasTags = spec.tags.length > 0;
+                if (!hasTags && !hasPrefix) return {};
+                if (!hasTags && hasPrefix) return {
+                    Prefix: spec.prefix
+                };
+                if (hasTags && !hasPrefix) {
+                    if (1 === spec.tags.length) return {
+                        Tag: {
+                            Key: spec.tags[0].key,
+                            Value: spec.tags[0].value
+                        }
+                    };
+                    return {
+                        And: {
+                            Tags: spec.tags.map((tag)=>({
+                                    Key: tag.key,
+                                    Value: tag.value
+                                }))
+                        }
+                    };
+                }
+                return {
+                    And: {
+                        Prefix: spec.prefix,
+                        Tags: spec.tags.map((tag)=>({
+                                Key: tag.key,
+                                Value: tag.value
+                            }))
+                    }
+                };
+            }
+    }
+}
+export { AWS_RULE_LIMITS, STATUS_OPTIONS, buildS3Filter, toFilterSpec };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scality/data-browser-library",
-  "version": "1.0.0-preview.8",
+  "version": "1.0.1",
   "description": "A modular React component library for browsing S3 buckets and objects",
   "type": "module",
   "types": "./dist/index.d.ts",
@@ -18,7 +18,9 @@
     "build": "rslib build",
     "dev": "rslib build --watch",
     "type-check": "tsc --noEmit",
-    "lint": "eslint src --ext .ts,.tsx",
+    "lint": "biome check .",
+    "lint:fix": "biome check --write .",
+    "format": "biome format --write .",
     "test": "jest",
     "clean": "rm -rf dist"
   },
@@ -29,24 +31,24 @@
     "@aws-sdk/s3-request-presigner": "^3.478.0",
     "@hookform/resolvers": "^5.2.2",
     "@monaco-editor/react": "^4.7.0",
+    "@scality/zenkoclient": "^2.0.0-preview.1",
     "@tanstack/react-query": "^5.8.0",
     "@tanstack/react-query-devtools": "^5.8.0",
     "@testing-library/user-event": "^14.6.1",
     "joi": "^18.0.1",
     "react-dropzone": "^14.2.0",
-    "react-hook-form": "^7.48.0",
-    "@scality/zenkoclient": "^2.0.0-preview.1"
+    "react-hook-form": "^7.48.0"
   },
   "peerDependencies": {
-    "@scality/core-ui": "^0.174.0",
+    "@scality/core-ui": "0.194.0",
     "react": ">=18.0.0",
     "react-dom": ">=18.0.0",
     "react-router-dom": ">=6.0.0",
     "styled-components": "^5.0.0"
   },
   "devDependencies": {
-    "@rsbuild/plugin-react": "^1.4.1",
-    "@rslib/core": "^0.14.0",
+    "@rsbuild/plugin-react": "^1.4.2",
+    "@rslib/core": "^0.18.4",
     "@testing-library/jest-dom": "^6.8.0",
     "@testing-library/react": "^15.0.6",
     "@testing-library/user-event": "^14.6.1",
@@ -57,7 +59,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": {