@wener/common 2.0.1 → 2.0.3

package/lib/s3/formatS3Url.test.js

@@ -0,0 +1,262 @@
+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");
+    });
+});

package/lib/s3/index.js

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

package/lib/s3/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/s3/index.ts"],"sourcesContent":["export { parseS3Url, type ParseS3UrlOptions } from './parseS3Url';\nexport { formatS3Url } from './formatS3Url';\n"],"names":["parseS3Url","formatS3Url"],"mappings":"AAAA,SAASA,UAAU,QAAgC,eAAe;AAClE,SAASC,WAAW,QAAQ,gBAAgB"}

package/lib/s3/parseS3Url.js

@@ -0,0 +1,65 @@
+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);
+}
+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;
+}
+
+//# sourceMappingURL=parseS3Url.js.map

package/lib/s3/parseS3Url.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/s3/parseS3Url.ts"],"sourcesContent":["import { parseBoolean } from '@wener/utils';\n\nexport type ParsedS3Options = {\n\taccessKeyId?: string;\n\tsecretAccessKey?: string;\n\tregion?: string;\n\tuseSsl?: boolean;\n\tbucket?: string;\n\tendpoint: string;\n\tport?: number;\n\tpathStyle?: boolean;\n\turl?: string;\n};\n\nexport type ParseS3UrlOptions = Partial<ParsedS3Options>;\n\nfunction isValidIpAddress(hostname: string): boolean {\n\tconst 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]?)$/;\n\tconst ipv6Regex = /^\\[([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}]$/;\n\treturn ipv4Regex.test(hostname) || ipv6Regex.test(hostname);\n}\n\nexport function parseS3Url({ url = process.env.S3_URL, ...rest }: ParseS3UrlOptions = {}): ParsedS3Options | undefined {\n\tif (!url) return undefined;\n\n\tconst normalizedUrl = url.startsWith('s3://') ? url.replace(/^s3:\\/\\//, 'https://') : url;\n\tlet parsed: URL;\n\ttry {\n\t\tparsed = new URL(normalizedUrl);\n\t} catch (error) {\n\t\tthrow new Error(`Invalid S3 URL: ${url}`);\n\t}\n\n\tconst pathStyleParam = parsed.searchParams.get('pathStyle');\n\tlet pathStyle: boolean | undefined = rest.pathStyle;\n\tpathStyle ??= parseBoolean(pathStyleParam, true);\n\n\t// Auto-detect path style for IP addresses\n\tif (pathStyle === undefined && isValidIpAddress(parsed.hostname)) {\n\t\tpathStyle = true;\n\t}\n\n\tconst result: ParsedS3Options = {\n\t\taccessKeyId: parsed.username || undefined,\n\t\tsecretAccessKey: parsed.password || undefined,\n\t\tendpoint: parsed.hostname,\n\t\tport: parsed.port ? Number(parsed.port) : undefined,\n\t\tuseSsl: parsed.protocol === 'https:',\n\t\tregion: parsed.searchParams.get('region') || undefined,\n\t\tpathStyle,\n\t};\n\n\tif (!result.port) {\n\t\tif (result.useSsl) {\n\t\t\tresult.port = 443;\n\t\t} else {\n\t\t\tresult.port = 80;\n\t\t}\n\t}\n\n\tconst pathSegments = parsed.pathname.split('/').filter(Boolean);\n\tconst awsVirtualHostMatch = parsed.hostname.match(/^(.*?)\\.s3[.-]([a-z0-9-]+)?\\.?amazonaws\\.com$/);\n\n\tif (result.pathStyle) {\n\t\tresult.bucket = pathSegments[0];\n\t} else if (awsVirtualHostMatch) {\n\t\tresult.bucket = awsVirtualHostMatch[1];\n\t\tresult.endpoint = parsed.hostname;\n\t\tif (!result.region && awsVirtualHostMatch[2]) {\n\t\t\tresult.region = awsVirtualHostMatch[2];\n\t\t}\n\t\tresult.pathStyle = false;\n\t} else {\n\t\tresult.bucket = pathSegments[0];\n\t\tif (result.pathStyle === undefined) {\n\t\t\tresult.pathStyle = true;\n\t\t}\n\t}\n\n\t// Type-safe property assignment\n\tfor (const [key, value] of Object.entries(rest)) {\n\t\tif (value !== undefined && value !== null && key in result) {\n\t\t\t(result as Record<string, unknown>)[key] = value;\n\t\t}\n\t}\n\n\treturn result;\n}\n"],"names":["parseBoolean","isValidIpAddress","hostname","ipv4Regex","ipv6Regex","test","parseS3Url","url","process","env","S3_URL","rest","undefined","normalizedUrl","startsWith","replace","parsed","URL","error","Error","pathStyleParam","searchParams","get","pathStyle","result","accessKeyId","username","secretAccessKey","password","endpoint","port","Number","useSsl","protocol","region","pathSegments","pathname","split","filter","Boolean","awsVirtualHostMatch","match","bucket","key","value","Object","entries"],"mappings":"AAAA,SAASA,YAAY,QAAQ,eAAe;AAgB5C,SAASC,iBAAiBC,QAAgB;IACzC,MAAMC,YAAY;IAClB,MAAMC,YAAY;IAClB,OAAOD,UAAUE,IAAI,CAACH,aAAaE,UAAUC,IAAI,CAACH;AACnD;AAEA,OAAO,SAASI,WAAW,EAAEC,MAAMC,QAAQC,GAAG,CAACC,MAAM,EAAE,GAAGC,MAAyB,GAAG,CAAC,CAAC;IACvF,IAAI,CAACJ,KAAK,OAAOK;IAEjB,MAAMC,gBAAgBN,IAAIO,UAAU,CAAC,WAAWP,IAAIQ,OAAO,CAAC,YAAY,cAAcR;IACtF,IAAIS;IACJ,IAAI;QACHA,SAAS,IAAIC,IAAIJ;IAClB,EAAE,OAAOK,OAAO;QACf,MAAM,IAAIC,MAAM,CAAC,gBAAgB,EAAEZ,KAAK;IACzC;IAEA,MAAMa,iBAAiBJ,OAAOK,YAAY,CAACC,GAAG,CAAC;IAC/C,IAAIC,YAAiCZ,KAAKY,SAAS;IACnDA,cAAcvB,aAAaoB,gBAAgB;IAE3C,0CAA0C;IAC1C,IAAIG,cAAcX,aAAaX,iBAAiBe,OAAOd,QAAQ,GAAG;QACjEqB,YAAY;IACb;IAEA,MAAMC,SAA0B;QAC/BC,aAAaT,OAAOU,QAAQ,IAAId;QAChCe,iBAAiBX,OAAOY,QAAQ,IAAIhB;QACpCiB,UAAUb,OAAOd,QAAQ;QACzB4B,MAAMd,OAAOc,IAAI,GAAGC,OAAOf,OAAOc,IAAI,IAAIlB;QAC1CoB,QAAQhB,OAAOiB,QAAQ,KAAK;QAC5BC,QAAQlB,OAAOK,YAAY,CAACC,GAAG,CAAC,aAAaV;QAC7CW;IACD;IAEA,IAAI,CAACC,OAAOM,IAAI,EAAE;QACjB,IAAIN,OAAOQ,MAAM,EAAE;YAClBR,OAAOM,IAAI,GAAG;QACf,OAAO;YACNN,OAAOM,IAAI,GAAG;QACf;IACD;IAEA,MAAMK,eAAenB,OAAOoB,QAAQ,CAACC,KAAK,CAAC,KAAKC,MAAM,CAACC;IACvD,MAAMC,sBAAsBxB,OAAOd,QAAQ,CAACuC,KAAK,CAAC;IAElD,IAAIjB,OAAOD,SAAS,EAAE;QACrBC,OAAOkB,MAAM,GAAGP,YAAY,CAAC,EAAE;IAChC,OAAO,IAAIK,qBAAqB;QAC/BhB,OAAOkB,MAAM,GAAGF,mBAAmB,CAAC,EAAE;QACtChB,OAAOK,QAAQ,GAAGb,OAAOd,QAAQ;QACjC,IAAI,CAACsB,OAAOU,MAAM,IAAIM,mBAAmB,CAAC,EAAE,EAAE;YAC7ChB,OAAOU,MAAM,GAAGM,mBAAmB,CAAC,EAAE;QACvC;QACAhB,OAAOD,SAAS,GAAG;IACpB,OAAO;QACNC,OAAOkB,MAAM,GAAGP,YAAY,CAAC,EAAE;QAC/B,IAAIX,OAAOD,SAAS,KAAKX,WAAW;YACnCY,OAAOD,SAAS,GAAG;QACpB;IACD;IAEA,gCAAgC;IAChC,KAAK,MAAM,CAACoB,KAAKC,MAAM,IAAIC,OAAOC,OAAO,CAACnC,MAAO;QAChD,IAAIiC,UAAUhC,aAAagC,UAAU,QAAQD,OAAOnB,QAAQ;YAC1DA,MAAkC,CAACmB,IAAI,GAAGC;QAC5C;IACD;IAEA,OAAOpB;AACR"}

package/lib/s3/parseS3Url.test.js

@@ -0,0 +1,270 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { parseS3Url } from "./parseS3Url.js";
+describe("parseS3Url", function () {
+    beforeEach(function () {
+        vi.restoreAllMocks();
+    });
+    it("should return undefined for empty URL", function () {
+        var result = parseS3Url({
+            url: ""
+        });
+        expect(result).toBeUndefined();
+    });
+    it("should return undefined for undefined URL", function () {
+        var result = parseS3Url({
+            url: undefined
+        });
+        expect(result).toBeUndefined();
+    });
+    it("should parse basic HTTPS URL", function () {
+        var result = parseS3Url({
+            url: "https://s3.amazonaws.com/bucket-name"
+        });
+        expect(result).toEqual({
+            accessKeyId: undefined,
+            secretAccessKey: undefined,
+            endpoint: "s3.amazonaws.com",
+            port: 443,
+            useSsl: true,
+            region: undefined,
+            pathStyle: true,
+            bucket: "bucket-name"
+        });
+    });
+    it("should parse basic HTTP URL", function () {
+        var result = parseS3Url({
+            url: "http://s3.amazonaws.com/bucket-name"
+        });
+        expect(result).toEqual({
+            accessKeyId: undefined,
+            secretAccessKey: undefined,
+            endpoint: "s3.amazonaws.com",
+            port: 80,
+            useSsl: false,
+            region: undefined,
+            pathStyle: true,
+            bucket: "bucket-name"
+        });
+    });
+    it("should parse S3 protocol URL", function () {
+        var result = parseS3Url({
+            url: "s3://s3.amazonaws.com/bucket-name"
+        });
+        expect(result).toEqual({
+            accessKeyId: undefined,
+            secretAccessKey: undefined,
+            endpoint: "s3.amazonaws.com",
+            port: 443,
+            useSsl: true,
+            region: undefined,
+            pathStyle: true,
+            bucket: "bucket-name"
+        });
+    });
+    it("should parse URL with credentials", function () {
+        var result = parseS3Url({
+            url: "https://user:pass@s3.amazonaws.com/bucket-name"
+        });
+        expect(result).toEqual({
+            accessKeyId: "user",
+            secretAccessKey: "pass",
+            endpoint: "s3.amazonaws.com",
+            port: 443,
+            useSsl: true,
+            region: undefined,
+            pathStyle: true,
+            bucket: "bucket-name"
+        });
+    });
+    it("should parse URL with port", function () {
+        var result = parseS3Url({
+            url: "https://s3.amazonaws.com:9000/bucket-name"
+        });
+        expect(result).toEqual({
+            accessKeyId: undefined,
+            secretAccessKey: undefined,
+            endpoint: "s3.amazonaws.com",
+            port: 9000,
+            useSsl: true,
+            region: undefined,
+            pathStyle: true,
+            bucket: "bucket-name"
+        });
+    });
+    it("should parse URL with region query parameter", function () {
+        var result = parseS3Url({
+            url: "https://s3.amazonaws.com/bucket-name?region=us-east-1"
+        });
+        expect(result).toEqual({
+            accessKeyId: undefined,
+            secretAccessKey: undefined,
+            endpoint: "s3.amazonaws.com",
+            port: 443,
+            useSsl: true,
+            region: "us-east-1",
+            pathStyle: true,
+            bucket: "bucket-name"
+        });
+    });
+    it("should parse URL with pathStyle parameter", function () {
+        var result = parseS3Url({
+            url: "https://s3.amazonaws.com/bucket-name?pathStyle=true"
+        });
+        expect(result).toEqual({
+            accessKeyId: undefined,
+            secretAccessKey: undefined,
+            endpoint: "s3.amazonaws.com",
+            port: 443,
+            useSsl: true,
+            region: undefined,
+            pathStyle: true,
+            bucket: "bucket-name"
+        });
+    });
+    it("should parse URL with pathStyle=false parameter", function () {
+        var result = parseS3Url({
+            url: "https://s3.amazonaws.com/bucket-name?pathStyle=false"
+        });
+        expect(result).toEqual({
+            accessKeyId: undefined,
+            secretAccessKey: undefined,
+            endpoint: "s3.amazonaws.com",
+            port: 443,
+            useSsl: true,
+            region: undefined,
+            pathStyle: false,
+            bucket: "bucket-name"
+        });
+    });
+    it("should detect path style for IP addresses", function () {
+        var result = parseS3Url({
+            url: "https://192.168.1.1/bucket-name"
+        });
+        expect(result).toEqual({
+            accessKeyId: undefined,
+            secretAccessKey: undefined,
+            endpoint: "192.168.1.1",
+            port: 443,
+            useSsl: true,
+            region: undefined,
+            pathStyle: true,
+            bucket: "bucket-name"
+        });
+    });
+    it("should detect path style for IPv6 addresses", function () {
+        var result = parseS3Url({
+            url: "https://[2001:db8::1]/bucket-name"
+        });
+        expect(result).toEqual({
+            accessKeyId: undefined,
+            secretAccessKey: undefined,
+            endpoint: "[2001:db8::1]",
+            port: 443,
+            useSsl: true,
+            region: undefined,
+            pathStyle: true,
+            bucket: "bucket-name"
+        });
+    });
+    it("should parse AWS virtual hosted style URL", function () {
+        var result = parseS3Url({
+            url: "https://my-bucket.s3.us-east-1.amazonaws.com"
+        });
+        expect(result).toEqual({
+            accessKeyId: undefined,
+            secretAccessKey: undefined,
+            endpoint: "my-bucket.s3.us-east-1.amazonaws.com",
+            port: 443,
+            useSsl: true,
+            region: "us-east-1",
+            pathStyle: false,
+            bucket: "my-bucket"
+        });
+    });
+    it("should parse AWS virtual hosted style URL with custom endpoint", function () {
+        var result = parseS3Url({
+            url: "https://my-bucket.s3.amazonaws.com"
+        });
+        expect(result).toEqual({
+            accessKeyId: undefined,
+            secretAccessKey: undefined,
+            endpoint: "my-bucket.s3.amazonaws.com",
+            port: 443,
+            useSsl: true,
+            region: undefined,
+            pathStyle: false,
+            bucket: "my-bucket"
+        });
+    });
+    it("should override parameters with provided options", function () {
+        var result = parseS3Url({
+            url: "https://s3.amazonaws.com/bucket-name",
+            region: "us-west-2",
+            pathStyle: false
+        });
+        expect(result).toEqual({
+            accessKeyId: undefined,
+            secretAccessKey: undefined,
+            endpoint: "s3.amazonaws.com",
+            port: 443,
+            useSsl: true,
+            region: "us-west-2",
+            pathStyle: false,
+            bucket: "bucket-name"
+        });
+    });
+    it("should use S3_URL environment variable by default", function () {
+        vi.stubEnv("S3_URL", "https://env-bucket.s3.amazonaws.com");
+        var result = parseS3Url();
+        expect(result).toEqual({
+            accessKeyId: undefined,
+            secretAccessKey: undefined,
+            endpoint: "env-bucket.s3.amazonaws.com",
+            port: 443,
+            useSsl: true,
+            region: undefined,
+            pathStyle: false,
+            bucket: "env-bucket"
+        });
+    });
+    it("should throw error for invalid URL", function () {
+        expect(function () {
+            return parseS3Url({
+                url: "invalid-url"
+            });
+        }).toThrow("Invalid S3 URL: invalid-url");
+    });
+    it("should handle complex URL with multiple parameters", function () {
+        var result = parseS3Url({
+            url: "https://user:pass@custom-s3.com:9000/my-bucket?region=us-east-1&pathStyle=true"
+        });
+        expect(result).toEqual({
+            accessKeyId: "user",
+            secretAccessKey: "pass",
+            endpoint: "custom-s3.com",
+            port: 9000,
+            useSsl: true,
+            region: "us-east-1",
+            pathStyle: true,
+            bucket: "my-bucket"
+        });
+    });
+    it("should ignore undefined and null values in rest parameters", function () {
+        var result = parseS3Url({
+            url: "https://s3.amazonaws.com/bucket-name",
+            region: "us-west-2",
+            port: undefined,
+            useSsl: null
+        });
+        expect(result).toEqual({
+            accessKeyId: undefined,
+            secretAccessKey: undefined,
+            endpoint: "s3.amazonaws.com",
+            port: 443,
+            useSsl: true,
+            region: "us-west-2",
+            pathStyle: true,
+            bucket: "bucket-name"
+        });
+    });
+});

package/lib/schema/SchemaRegistry.js

@@ -0,0 +1,45 @@
+import { getGlobalStates } from "@wener/utils";
+import { toJsonSchema } from "./index.js";
+(function (SchemaRegistry) {
+    const types = getGlobalStates("@wener/common/resource/schema/SchemaRegistry", () => new Map());
+    function get(needle) {
+        let key = getKey(needle);
+        let found = types.get(key);
+        if (found) {
+            return found;
+        }
+        else {
+            if (needle && typeof needle !== "string") {
+                return toJsonSchema(needle);
+            }
+        }
+        throw new Error(`Schema not found: ${key}`);
+    }
+    SchemaRegistry.get = get;
+    function getKey(s) {
+        let key;
+        if (typeof s === "string") {
+            key = s;
+        }
+        else {
+            let js = toJsonSchema(s);
+            key = js.$id || js.title;
+        }
+        if (!key) {
+            throw new Error(`Schema must have $id or title`);
+        }
+        return key;
+    }
+    function set(key, def) {
+        if (!def) {
+            def = key;
+            if (!def || typeof def !== "object") {
+                throw new Error(`Invalid schema definition for: ${getKey(key)}`);
+            }
+        }
+        types.set(getKey(key), toJsonSchema(def));
+    }
+    SchemaRegistry.set = set;
+})(SchemaRegistry || (SchemaRegistry = {}));
+export var SchemaRegistry;
+//# sourceMappingURL=SchemaRegistry.js.map

package/lib/schema/SchemaRegistry.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/schema/SchemaRegistry.ts"],"sourcesContent":["import { getGlobalStates } from '@wener/utils';\nimport type { JsonSchemaDef } from '../jsonschema';\nimport { toJsonSchema, type SchemaOutput, type TypeSchema } from './index';\n\nexport namespace SchemaRegistry {\n\tconst types = getGlobalStates('@wener/common/resource/schema/SchemaRegistry', () => new Map<string, JsonSchemaDef>());\n\n\texport function get(name: string): JsonSchemaDef;\n\texport function get<S extends TypeSchema>(schema: S): JsonSchemaDef<SchemaOutput<S>>;\n\texport function get(needle: TypeSchema | string) {\n\t\tlet key = getKey(needle);\n\t\tlet found = types.get(key);\n\t\tif (found) {\n\t\t\treturn found;\n\t\t} else {\n\t\t\tif (needle && typeof needle !== 'string') {\n\t\t\t\treturn toJsonSchema(needle);\n\t\t\t}\n\t\t}\n\t\tthrow new Error(`Schema not found: ${key}`);\n\t}\n\n\tfunction getKey(s: TypeSchema | string) {\n\t\tlet key;\n\t\tif (typeof s === 'string') {\n\t\t\tkey = s;\n\t\t} else {\n\t\t\tlet js = toJsonSchema(s);\n\t\t\tkey = js.$id || js.title;\n\t\t}\n\t\tif (!key) {\n\t\t\tthrow new Error(`Schema must have $id or title`);\n\t\t}\n\t\treturn key;\n\t}\n\n\texport function set(key: TypeSchema | string, def: TypeSchema): void;\n\texport function set(key: TypeSchema, def?: TypeSchema): void;\n\texport function set(key: TypeSchema | string, def?: TypeSchema) {\n\t\tif (!def) {\n\t\t\tdef = key as TypeSchema;\n\t\t\tif (!def || typeof def !== 'object') {\n\t\t\t\tthrow new Error(`Invalid schema definition for: ${getKey(key)}`);\n\t\t\t}\n\t\t}\n\t\ttypes.set(getKey(key), toJsonSchema(def));\n\t}\n}\n"],"names":["getGlobalStates","toJsonSchema","SchemaRegistry","types","Map","get","needle","key","getKey","found","Error","s","js","$id","title","set","def"],"mappings":"AAAA,SAASA,eAAe,QAAQ,eAAe;AAE/C,SAASC,YAAY,QAA4C,UAAU;UAE1DC;IAChB,MAAMC,QAAQH,gBAAgB,gDAAgD,IAAM,IAAII;IAIjF,SAASC,IAAIC,MAA2B;QAC9C,IAAIC,MAAMC,OAAOF;QACjB,IAAIG,QAAQN,MAAME,GAAG,CAACE;QACtB,IAAIE,OAAO;YACV,OAAOA;QACR,OAAO;YACN,IAAIH,UAAU,OAAOA,WAAW,UAAU;gBACzC,OAAOL,aAAaK;YACrB;QACD;QACA,MAAM,IAAII,MAAM,CAAC,kBAAkB,EAAEH,KAAK;IAC3C;mBAXgBF,MAAAA;IAahB,SAASG,OAAOG,CAAsB;QACrC,IAAIJ;QACJ,IAAI,OAAOI,MAAM,UAAU;YAC1BJ,MAAMI;QACP,OAAO;YACN,IAAIC,KAAKX,aAAaU;YACtBJ,MAAMK,GAAGC,GAAG,IAAID,GAAGE,KAAK;QACzB;QACA,IAAI,CAACP,KAAK;YACT,MAAM,IAAIG,MAAM,CAAC,6BAA6B,CAAC;QAChD;QACA,OAAOH;IACR;IAIO,SAASQ,IAAIR,GAAwB,EAAES,GAAgB;QAC7D,IAAI,CAACA,KAAK;YACTA,MAAMT;YACN,IAAI,CAACS,OAAO,OAAOA,QAAQ,UAAU;gBACpC,MAAM,IAAIN,MAAM,CAAC,+BAA+B,EAAEF,OAAOD,MAAM;YAChE;QACD;QACAJ,MAAMY,GAAG,CAACP,OAAOD,MAAMN,aAAae;IACrC;mBARgBD,MAAAA;AASjB,GA3CiBb,mBAAAA"}

package/lib/schema/SchemaRegistry.mod.js

@@ -0,0 +1,2 @@
+import * as _SchemaRegistry from "./SchemaRegistry.js";
+export { _SchemaRegistry as SchemaRegistry };

package/lib/schema/TypeSchema.d.js

@@ -1 +1,3 @@
 export { };
+
+//# sourceMappingURL=TypeSchema.d.js.map