@wener/common 2.0.5 → 2.0.6

package/lib/s3/parseS3Url.test.js

@@ -1,270 +1,271 @@
-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"
-        });
-    });
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { parseS3Url } from './parseS3Url.js';
+
+describe('parseS3Url', () => {
+	beforeEach(() => {
+		vi.restoreAllMocks();
+	});
+	it('should return undefined for empty URL', () => {
+		var result = parseS3Url({
+			url: '',
+		});
+		expect(result).toBeUndefined();
+	});
+	it('should return undefined for undefined URL', () => {
+		var result = parseS3Url({
+			url: undefined,
+		});
+		expect(result).toBeUndefined();
+	});
+	it('should parse basic HTTPS URL', () => {
+		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', () => {
+		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', () => {
+		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', () => {
+		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', () => {
+		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', () => {
+		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', () => {
+		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', () => {
+		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', () => {
+		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', () => {
+		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', () => {
+		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', () => {
+		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', () => {
+		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', () => {
+		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', () => {
+		expect(() =>
+			parseS3Url({
+				url: 'invalid-url',
+			}),
+		).toThrow('Invalid S3 URL: invalid-url');
+	});
+	it('should handle complex URL with multiple parameters', () => {
+		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', () => {
+		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

@@ -1,45 +1,44 @@
-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;
+import { getGlobalStates } from '@wener/utils';
+import { toJsonSchema } from './index.js';
+
+((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.mod.js

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

package/lib/schema/TypeSchema.d.js

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