@wener/common 2.0.3 → 2.0.6

package/lib/s3/formatS3Url.test.js

@@ -1,262 +1,239 @@
-import { describe, expect, it } from "vitest";
-import { formatS3Url } from "./formatS3Url.js";
-describe("formatS3Url", function () {
-    it("should format basic S3 URL with default endpoint", function () {
-        var options = {
-            endpoint: "s3.amazonaws.com"
-        };
-        var result = formatS3Url(options);
-        expect(result).toBe("https://s3.amazonaws.com/");
-    });
-    it("should format S3 URL with custom endpoint", function () {
-        var options = {
-            endpoint: "custom-s3.com"
-        };
-        var result = formatS3Url(options);
-        expect(result).toBe("https://custom-s3.com/");
-    });
-    it("should format S3 URL with HTTP protocol", function () {
-        var options = {
-            endpoint: "s3.amazonaws.com",
-            useSsl: false
-        };
-        var result = formatS3Url(options);
-        expect(result).toBe("http://s3.amazonaws.com/");
-    });
-    it("should format S3 URL with port", function () {
-        var options = {
-            endpoint: "s3.amazonaws.com",
-            port: 9000
-        };
-        var result = formatS3Url(options);
-        expect(result).toBe("https://s3.amazonaws.com:9000/");
-    });
-    it("should format S3 URL with bucket in path style", function () {
-        var options = {
-            endpoint: "s3.amazonaws.com",
-            bucket: "my-bucket",
-            pathStyle: true
-        };
-        var result = formatS3Url(options);
-        expect(result).toBe("https://s3.amazonaws.com/my-bucket/");
-    });
-    it("should format S3 URL with bucket in virtual hosted style", function () {
-        var options = {
-            endpoint: "s3.amazonaws.com",
-            bucket: "my-bucket",
-            pathStyle: false
-        };
-        var result = formatS3Url(options);
-        expect(result).toBe("https://my-bucket.s3.amazonaws.com/");
-    });
-    it("should format S3 URL with credentials", function () {
-        var options = {
-            endpoint: "s3.amazonaws.com",
-            accessKeyId: "user",
-            secretAccessKey: "pass"
-        };
-        var result = formatS3Url(options, {
-            credentials: true
-        });
-        expect(result).toBe("https://user:pass@s3.amazonaws.com/");
-    });
-    it("should format S3 URL with credentials and special characters", function () {
-        var options = {
-            endpoint: "s3.amazonaws.com",
-            accessKeyId: "user@example.com",
-            secretAccessKey: "pass/word"
-        };
-        var result = formatS3Url(options, {
-            credentials: true
-        });
-        expect(result).toBe("https://user%40example.com:pass%2Fword@s3.amazonaws.com/");
-    });
-    it("should format S3 URL with region in query parameters", function () {
-        var options = {
-            endpoint: "s3.amazonaws.com",
-            region: "us-east-1"
-        };
-        var result = formatS3Url(options, {
-            useParams: true
-        });
-        expect(result).toBe("https://s3.amazonaws.com/?region=us-east-1");
-    });
-    it("should format S3 URL with pathStyle in query parameters", function () {
-        var options = {
-            endpoint: "s3.amazonaws.com",
-            pathStyle: true
-        };
-        var result = formatS3Url(options, {
-            useParams: true
-        });
-        expect(result).toBe("https://s3.amazonaws.com/?pathStyle=true");
-    });
-    it("should format S3 URL with all parameters", function () {
-        var options = {
-            endpoint: "s3.amazonaws.com",
-            accessKeyId: "user",
-            secretAccessKey: "pass",
-            region: "us-east-1",
-            port: 9000,
-            bucket: "my-bucket",
-            pathStyle: true,
-            useSsl: true
-        };
-        var result = formatS3Url(options, {
-            credentials: true,
-            useParams: true
-        });
-        expect(result).toBe("https://user:pass@s3.amazonaws.com:9000/my-bucket/?region=us-east-1&pathStyle=true");
-    });
-    it("should handle full URL as endpoint", function () {
-        var options = {
-            endpoint: "https://custom-s3.com:9000",
-            bucket: "my-bucket",
-            pathStyle: true
-        };
-        var result = formatS3Url(options);
-        expect(result).toBe("https://custom-s3.com:9000/my-bucket/");
-    });
-    it("should handle complex virtual hosted style with existing bucket in hostname", function () {
-        var options = {
-            endpoint: "my-bucket.s3.amazonaws.com",
-            bucket: "my-bucket",
-            pathStyle: false
-        };
-        var result = formatS3Url(options);
-        expect(result).toBe("https://my-bucket.s3.amazonaws.com/");
-    });
-    it("should throw error for missing endpoint", function () {
-        var options = {};
-        expect(function () {
-            return formatS3Url(options);
-        }).toThrow("Endpoint is required");
-    });
-    it("should handle endpoint without protocol by adding https://", function () {
-        var options = {
-            endpoint: "custom-s3.com"
-        };
-        var result = formatS3Url(options);
-        expect(result).toBe("https://custom-s3.com/");
-    });
-    it("should throw error for missing credentials when credentials=true", function () {
-        var options = {
-            endpoint: "s3.amazonaws.com",
-            accessKeyId: "user"
-        };
-        expect(function () {
-            return formatS3Url(options, {
-                credentials: true
-            });
-        }).toThrow("Access Key ID and Secret Access Key are required for credentials");
-    });
-    it("should throw error for invalid port", function () {
-        var options = {
-            endpoint: "s3.amazonaws.com",
-            port: 99999
-        };
-        expect(function () {
-            return formatS3Url(options);
-        }).toThrow("Port must be a valid number between 1 and 65535");
-    });
-    it("should throw error for invalid bucket name", function () {
-        var options = {
-            endpoint: "s3.amazonaws.com",
-            bucket: "Invalid Bucket Name"
-        };
-        expect(function () {
-            return formatS3Url(options);
-        }).toThrow("Invalid bucket name: Invalid Bucket Name");
-    });
-    it("should throw error for bucket name with consecutive dots", function () {
-        var options = {
-            endpoint: "s3.amazonaws.com",
-            bucket: "my..bucket"
-        };
-        expect(function () {
-            return formatS3Url(options);
-        }).toThrow("Invalid bucket name: my..bucket");
-    });
-    it("should throw error for bucket name with hyphen at start", function () {
-        var options = {
-            endpoint: "s3.amazonaws.com",
-            bucket: "-mybucket"
-        };
-        expect(function () {
-            return formatS3Url(options);
-        }).toThrow("Invalid bucket name: -mybucket");
-    });
-    it("should throw error for bucket name with hyphen at end", function () {
-        var options = {
-            endpoint: "s3.amazonaws.com",
-            bucket: "mybucket-"
-        };
-        expect(function () {
-            return formatS3Url(options);
-        }).toThrow("Invalid bucket name: mybucket-");
-    });
-    it("should handle bucket name with dot-hyphen (currently allowed)", function () {
-        var options = {
-            endpoint: "s3.amazonaws.com",
-            bucket: "my.bucket-name",
-            pathStyle: true
-        };
-        var result = formatS3Url(options);
-        expect(result).toBe("https://s3.amazonaws.com/my.bucket-name/");
-    });
-    it("should throw error for bucket name that is too short", function () {
-        var options = {
-            endpoint: "s3.amazonaws.com",
-            bucket: "ab"
-        };
-        expect(function () {
-            return formatS3Url(options);
-        }).toThrow("Invalid bucket name: ab");
-    });
-    it("should throw error for bucket name that is too long", function () {
-        var options = {
-            endpoint: "s3.amazonaws.com",
-            bucket: "a".repeat(64)
-        };
-        expect(function () {
-            return formatS3Url(options);
-        }).toThrow("Invalid bucket name: " + "a".repeat(64));
-    });
-    it("should handle valid bucket names with various formats", function () {
-        var validBuckets = [
-            "my-bucket",
-            "my.bucket",
-            "mybucket123",
-            "123bucket",
-            "test-bucket-123"
-        ];
-        validBuckets.forEach(function (bucket) {
-            var options = {
-                endpoint: "s3.amazonaws.com",
-                bucket: bucket,
-                pathStyle: true
-            };
-            expect(function () {
-                return formatS3Url(options);
-            }).not.toThrow();
-        });
-    });
-    it("should handle pathname concatenation correctly in path style", function () {
-        var options = {
-            endpoint: "https://s3.amazonaws.com/path/to/something",
-            bucket: "my-bucket",
-            pathStyle: true
-        };
-        var result = formatS3Url(options);
-        expect(result).toBe("https://s3.amazonaws.com/my-bucket/path/to/something");
-    });
-    it("should handle URL with existing pathname in virtual hosted style", function () {
-        var options = {
-            endpoint: "https://s3.amazonaws.com/path/to/something",
-            bucket: "my-bucket",
-            pathStyle: false
-        };
-        var result = formatS3Url(options);
-        expect(result).toBe("https://my-bucket.s3.amazonaws.com/path/to/something");
-    });
+import { describe, expect, it } from 'vitest';
+import { formatS3Url } from './formatS3Url.js';
+
+describe('formatS3Url', () => {
+	it('should format basic S3 URL with default endpoint', () => {
+		var options = {
+			endpoint: 's3.amazonaws.com',
+		};
+		var result = formatS3Url(options);
+		expect(result).toBe('https://s3.amazonaws.com/');
+	});
+	it('should format S3 URL with custom endpoint', () => {
+		var options = {
+			endpoint: 'custom-s3.com',
+		};
+		var result = formatS3Url(options);
+		expect(result).toBe('https://custom-s3.com/');
+	});
+	it('should format S3 URL with HTTP protocol', () => {
+		var options = {
+			endpoint: 's3.amazonaws.com',
+			useSsl: false,
+		};
+		var result = formatS3Url(options);
+		expect(result).toBe('http://s3.amazonaws.com/');
+	});
+	it('should format S3 URL with port', () => {
+		var options = {
+			endpoint: 's3.amazonaws.com',
+			port: 9000,
+		};
+		var result = formatS3Url(options);
+		expect(result).toBe('https://s3.amazonaws.com:9000/');
+	});
+	it('should format S3 URL with bucket in path style', () => {
+		var options = {
+			endpoint: 's3.amazonaws.com',
+			bucket: 'my-bucket',
+			pathStyle: true,
+		};
+		var result = formatS3Url(options);
+		expect(result).toBe('https://s3.amazonaws.com/my-bucket/');
+	});
+	it('should format S3 URL with bucket in virtual hosted style', () => {
+		var options = {
+			endpoint: 's3.amazonaws.com',
+			bucket: 'my-bucket',
+			pathStyle: false,
+		};
+		var result = formatS3Url(options);
+		expect(result).toBe('https://my-bucket.s3.amazonaws.com/');
+	});
+	it('should format S3 URL with credentials', () => {
+		var options = {
+			endpoint: 's3.amazonaws.com',
+			accessKeyId: 'user',
+			secretAccessKey: 'pass',
+		};
+		var result = formatS3Url(options, {
+			credentials: true,
+		});
+		expect(result).toBe('https://user:pass@s3.amazonaws.com/');
+	});
+	it('should format S3 URL with credentials and special characters', () => {
+		var options = {
+			endpoint: 's3.amazonaws.com',
+			accessKeyId: 'user@example.com',
+			secretAccessKey: 'pass/word',
+		};
+		var result = formatS3Url(options, {
+			credentials: true,
+		});
+		expect(result).toBe('https://user%40example.com:pass%2Fword@s3.amazonaws.com/');
+	});
+	it('should format S3 URL with region in query parameters', () => {
+		var options = {
+			endpoint: 's3.amazonaws.com',
+			region: 'us-east-1',
+		};
+		var result = formatS3Url(options, {
+			useParams: true,
+		});
+		expect(result).toBe('https://s3.amazonaws.com/?region=us-east-1');
+	});
+	it('should format S3 URL with pathStyle in query parameters', () => {
+		var options = {
+			endpoint: 's3.amazonaws.com',
+			pathStyle: true,
+		};
+		var result = formatS3Url(options, {
+			useParams: true,
+		});
+		expect(result).toBe('https://s3.amazonaws.com/?pathStyle=true');
+	});
+	it('should format S3 URL with all parameters', () => {
+		var options = {
+			endpoint: 's3.amazonaws.com',
+			accessKeyId: 'user',
+			secretAccessKey: 'pass',
+			region: 'us-east-1',
+			port: 9000,
+			bucket: 'my-bucket',
+			pathStyle: true,
+			useSsl: true,
+		};
+		var result = formatS3Url(options, {
+			credentials: true,
+			useParams: true,
+		});
+		expect(result).toBe('https://user:pass@s3.amazonaws.com:9000/my-bucket/?region=us-east-1&pathStyle=true');
+	});
+	it('should handle full URL as endpoint', () => {
+		var options = {
+			endpoint: 'https://custom-s3.com:9000',
+			bucket: 'my-bucket',
+			pathStyle: true,
+		};
+		var result = formatS3Url(options);
+		expect(result).toBe('https://custom-s3.com:9000/my-bucket/');
+	});
+	it('should handle complex virtual hosted style with existing bucket in hostname', () => {
+		var options = {
+			endpoint: 'my-bucket.s3.amazonaws.com',
+			bucket: 'my-bucket',
+			pathStyle: false,
+		};
+		var result = formatS3Url(options);
+		expect(result).toBe('https://my-bucket.s3.amazonaws.com/');
+	});
+	it('should throw error for missing endpoint', () => {
+		var options = {};
+		expect(() => formatS3Url(options)).toThrow('Endpoint is required');
+	});
+	it('should handle endpoint without protocol by adding https://', () => {
+		var options = {
+			endpoint: 'custom-s3.com',
+		};
+		var result = formatS3Url(options);
+		expect(result).toBe('https://custom-s3.com/');
+	});
+	it('should throw error for missing credentials when credentials=true', () => {
+		var options = {
+			endpoint: 's3.amazonaws.com',
+			accessKeyId: 'user',
+		};
+		expect(() =>
+			formatS3Url(options, {
+				credentials: true,
+			}),
+		).toThrow('Access Key ID and Secret Access Key are required for credentials');
+	});
+	it('should throw error for invalid port', () => {
+		var options = {
+			endpoint: 's3.amazonaws.com',
+			port: 99999,
+		};
+		expect(() => formatS3Url(options)).toThrow('Port must be a valid number between 1 and 65535');
+	});
+	it('should throw error for invalid bucket name', () => {
+		var options = {
+			endpoint: 's3.amazonaws.com',
+			bucket: 'Invalid Bucket Name',
+		};
+		expect(() => formatS3Url(options)).toThrow('Invalid bucket name: Invalid Bucket Name');
+	});
+	it('should throw error for bucket name with consecutive dots', () => {
+		var options = {
+			endpoint: 's3.amazonaws.com',
+			bucket: 'my..bucket',
+		};
+		expect(() => formatS3Url(options)).toThrow('Invalid bucket name: my..bucket');
+	});
+	it('should throw error for bucket name with hyphen at start', () => {
+		var options = {
+			endpoint: 's3.amazonaws.com',
+			bucket: '-mybucket',
+		};
+		expect(() => formatS3Url(options)).toThrow('Invalid bucket name: -mybucket');
+	});
+	it('should throw error for bucket name with hyphen at end', () => {
+		var options = {
+			endpoint: 's3.amazonaws.com',
+			bucket: 'mybucket-',
+		};
+		expect(() => formatS3Url(options)).toThrow('Invalid bucket name: mybucket-');
+	});
+	it('should handle bucket name with dot-hyphen (currently allowed)', () => {
+		var options = {
+			endpoint: 's3.amazonaws.com',
+			bucket: 'my.bucket-name',
+			pathStyle: true,
+		};
+		var result = formatS3Url(options);
+		expect(result).toBe('https://s3.amazonaws.com/my.bucket-name/');
+	});
+	it('should throw error for bucket name that is too short', () => {
+		var options = {
+			endpoint: 's3.amazonaws.com',
+			bucket: 'ab',
+		};
+		expect(() => formatS3Url(options)).toThrow('Invalid bucket name: ab');
+	});
+	it('should throw error for bucket name that is too long', () => {
+		var options = {
+			endpoint: 's3.amazonaws.com',
+			bucket: 'a'.repeat(64),
+		};
+		expect(() => formatS3Url(options)).toThrow('Invalid bucket name: ' + 'a'.repeat(64));
+	});
+	it('should handle valid bucket names with various formats', () => {
+		var validBuckets = ['my-bucket', 'my.bucket', 'mybucket123', '123bucket', 'test-bucket-123'];
+		validBuckets.forEach((bucket) => {
+			var options = {
+				endpoint: 's3.amazonaws.com',
+				bucket: bucket,
+				pathStyle: true,
+			};
+			expect(() => formatS3Url(options)).not.toThrow();
+		});
+	});
+	it('should handle pathname concatenation correctly in path style', () => {
+		var options = {
+			endpoint: 'https://s3.amazonaws.com/path/to/something',
+			bucket: 'my-bucket',
+			pathStyle: true,
+		};
+		var result = formatS3Url(options);
+		expect(result).toBe('https://s3.amazonaws.com/my-bucket/path/to/something');
+	});
+	it('should handle URL with existing pathname in virtual hosted style', () => {
+		var options = {
+			endpoint: 'https://s3.amazonaws.com/path/to/something',
+			bucket: 'my-bucket',
+			pathStyle: false,
+		};
+		var result = formatS3Url(options);
+		expect(result).toBe('https://my-bucket.s3.amazonaws.com/path/to/something');
+	});
 });

package/lib/s3/index.js

@@ -1,3 +1,3 @@
-export { parseS3Url } from "./parseS3Url.js";
-export { formatS3Url } from "./formatS3Url.js";
+export { formatS3Url } from './formatS3Url.js';
+export { parseS3Url } from './parseS3Url.js';
 //# sourceMappingURL=index.js.map

package/lib/s3/parseS3Url.js

@@ -1,65 +1,66 @@
-import { parseBoolean } from "@wener/utils";
+import { parseBoolean } from '@wener/utils';
+
 function isValidIpAddress(hostname) {
-    const ipv4Regex = /^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/;
-    const ipv6Regex = /^\[([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}]$/;
-    return ipv4Regex.test(hostname) || ipv6Regex.test(hostname);
+	const ipv4Regex = /^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/;
+	const ipv6Regex = /^\[([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}]$/;
+	return ipv4Regex.test(hostname) || ipv6Regex.test(hostname);
 }
 export function parseS3Url({ url = process.env.S3_URL, ...rest } = {}) {
-    if (!url) return undefined;
-    const normalizedUrl = url.startsWith('s3://') ? url.replace(/^s3:\/\//, 'https://') : url;
-    let parsed;
-    try {
-        parsed = new URL(normalizedUrl);
-    } catch (error) {
-        throw new Error(`Invalid S3 URL: ${url}`);
-    }
-    const pathStyleParam = parsed.searchParams.get('pathStyle');
-    let pathStyle = rest.pathStyle;
-    pathStyle ??= parseBoolean(pathStyleParam, true);
-    // Auto-detect path style for IP addresses
-    if (pathStyle === undefined && isValidIpAddress(parsed.hostname)) {
-        pathStyle = true;
-    }
-    const result = {
-        accessKeyId: parsed.username || undefined,
-        secretAccessKey: parsed.password || undefined,
-        endpoint: parsed.hostname,
-        port: parsed.port ? Number(parsed.port) : undefined,
-        useSsl: parsed.protocol === 'https:',
-        region: parsed.searchParams.get('region') || undefined,
-        pathStyle
-    };
-    if (!result.port) {
-        if (result.useSsl) {
-            result.port = 443;
-        } else {
-            result.port = 80;
-        }
-    }
-    const pathSegments = parsed.pathname.split('/').filter(Boolean);
-    const awsVirtualHostMatch = parsed.hostname.match(/^(.*?)\.s3[.-]([a-z0-9-]+)?\.?amazonaws\.com$/);
-    if (result.pathStyle) {
-        result.bucket = pathSegments[0];
-    } else if (awsVirtualHostMatch) {
-        result.bucket = awsVirtualHostMatch[1];
-        result.endpoint = parsed.hostname;
-        if (!result.region && awsVirtualHostMatch[2]) {
-            result.region = awsVirtualHostMatch[2];
-        }
-        result.pathStyle = false;
-    } else {
-        result.bucket = pathSegments[0];
-        if (result.pathStyle === undefined) {
-            result.pathStyle = true;
-        }
-    }
-    // Type-safe property assignment
-    for (const [key, value] of Object.entries(rest)){
-        if (value !== undefined && value !== null && key in result) {
-            result[key] = value;
-        }
-    }
-    return result;
+	if (!url) return undefined;
+	const normalizedUrl = url.startsWith('s3://') ? url.replace(/^s3:\/\//, 'https://') : url;
+	let parsed;
+	try {
+		parsed = new URL(normalizedUrl);
+	} catch (_error) {
+		throw new Error(`Invalid S3 URL: ${url}`);
+	}
+	const pathStyleParam = parsed.searchParams.get('pathStyle');
+	let pathStyle = rest.pathStyle;
+	pathStyle ??= parseBoolean(pathStyleParam, true);
+	// Auto-detect path style for IP addresses
+	if (pathStyle === undefined && isValidIpAddress(parsed.hostname)) {
+		pathStyle = true;
+	}
+	const result = {
+		accessKeyId: parsed.username || undefined,
+		secretAccessKey: parsed.password || undefined,
+		endpoint: parsed.hostname,
+		port: parsed.port ? Number(parsed.port) : undefined,
+		useSsl: parsed.protocol === 'https:',
+		region: parsed.searchParams.get('region') || undefined,
+		pathStyle,
+	};
+	if (!result.port) {
+		if (result.useSsl) {
+			result.port = 443;
+		} else {
+			result.port = 80;
+		}
+	}
+	const pathSegments = parsed.pathname.split('/').filter(Boolean);
+	const awsVirtualHostMatch = parsed.hostname.match(/^(.*?)\.s3[.-]([a-z0-9-]+)?\.?amazonaws\.com$/);
+	if (result.pathStyle) {
+		result.bucket = pathSegments[0];
+	} else if (awsVirtualHostMatch) {
+		result.bucket = awsVirtualHostMatch[1];
+		result.endpoint = parsed.hostname;
+		if (!result.region && awsVirtualHostMatch[2]) {
+			result.region = awsVirtualHostMatch[2];
+		}
+		result.pathStyle = false;
+	} else {
+		result.bucket = pathSegments[0];
+		if (result.pathStyle === undefined) {
+			result.pathStyle = true;
+		}
+	}
+	// Type-safe property assignment
+	for (const [key, value] of Object.entries(rest)) {
+		if (value !== undefined && value !== null && key in result) {
+			result[key] = value;
+		}
+	}
+	return result;
 }
 
-//# sourceMappingURL=parseS3Url.js.map
+//# sourceMappingURL=parseS3Url.js.map