@wener/common 2.0.2 → 2.0.5

package/src/jsonschema/forEachJsonSchema.ts

@@ -0,0 +1,50 @@
+import type { JsonSchemaDef } from './types';
+
+export type VisitJsonSchemaContext = { path: string[]; parent?: JsonSchemaDef };
+
+export function forEachJsonSchema(js: JsonSchemaDef, cb: (js: JsonSchemaDef, ctx: VisitJsonSchemaContext) => void) {
+	const ctx: VisitJsonSchemaContext = { path: [] };
+	const _visit = (
+		js: JsonSchemaDef,
+		_f: (js: JsonSchemaDef, ctx: VisitJsonSchemaContext) => void,
+		parent: JsonSchemaDef | undefined,
+		path: string[],
+		_k?: string,
+	) => {
+		if (!js) {
+			return;
+		}
+		ctx.path = path;
+		ctx.parent = parent;
+		_f(js, ctx);
+		if (js.properties) {
+			for (const [k, v] of Object.entries(js.properties)) {
+				if (v) {
+					_visit(v, _f, js, path.concat(k), 'properties');
+				}
+			}
+		} else if (js.items) {
+			// array should be `key[].subkey` or `key.*.subkey`?
+			if (Array.isArray(js.items)) {
+				for (const v of js.items) {
+					_visit(v, _f, js, path, 'items');
+				}
+			} else {
+				_visit(js.items, _f, js, path, 'items');
+			}
+		} else if (js.anyOf) {
+			for (const v of js.anyOf) {
+				_visit(v, _f, js, path, 'anyOf');
+			}
+		} else if (js.oneOf) {
+			for (const v of js.oneOf) {
+				_visit(v, _f, js, path, 'oneOf');
+			}
+		} else if (js.allOf) {
+			for (const v of js.allOf) {
+				_visit(v, _f, js, path, 'allOf');
+			}
+		}
+	};
+	_visit(js, cb, undefined, []);
+}

package/src/jsonschema/index.ts

@@ -1,2 +1,3 @@
 export { JsonSchema } from './JsonSchema';
 export type { JsonSchemaDef } from './types';
+export { forEachJsonSchema } from './forEachJsonSchema';

package/src/jsonschema/types.d.ts

@@ -59,7 +59,7 @@ type JsonSchemaFormatName =
  *
  * @see https://json-schema.org/specification-links.html
  */
-export type JsonSchemaDef<I = any, O = I> = {
+export type JsonSchemaDef<I = any, _O = I> = {
 	$id?: string;
 	$ref?: string;
 	/**

package/src/meta/defineMetadata.ts

@@ -30,7 +30,7 @@ export function createMetadataKey<T = never>(a: any, b?: any): MetadataKey<T> {
 
 export function defineMetadata<T>(res: HasMetadata, key: MetadataKey<T>, opts: T): void;
 export function defineMetadata<T>(key: MetadataKey<T>, items: Array<[HasMetadata, T]>): void;
-export function defineMetadata<T>(a: any, b: any, c?: any) {
+export function defineMetadata<_T>(a: any, b: any, c?: any) {
 	if (Array.isArray(b)) {
 		const key = a;
 		const items = b;

package/src/orpc/createOpenApiContractClient.ts

@@ -0,0 +1,52 @@
+import { createORPCClient, type ClientContext } from '@orpc/client';
+import type { LinkFetchClientOptions } from '@orpc/client/fetch';
+import type { BatchLinkPluginOptions, DedupeRequestsPluginOptions } from '@orpc/client/plugins';
+import type { StandardLinkPlugin } from '@orpc/client/standard';
+import type { AnyContractRouter, ContractRouterClient } from '@orpc/contract';
+import type { JsonifiedClient } from '@orpc/openapi-client';
+import { OpenAPILink } from '@orpc/openapi-client/fetch';
+import type { PartialRequired } from '@wener/utils';
+import { buildBaseUrl } from '../utils/buildBaseUrl';
+import { resolveLinkPlugins } from './resolveLinkPlugins';
+
+export function createOpenApiContractClient<TContract extends AnyContractRouter>(
+	contract: TContract,
+	options: PartialRequired<CreateContractClientOptions, 'url'>,
+): JsonifiedClient<ContractRouterClient<TContract, ClientContext>> {
+	let { url, baseUrl, apiKey, getApiKey, getHeaders } = options;
+	const baseHeaders = new Headers(options.headers);
+	if (apiKey) {
+		baseHeaders.set('Authorization', `Bearer ${apiKey}`);
+	}
+	url = buildBaseUrl(url, baseUrl);
+	return createORPCClient(
+		new OpenAPILink(contract, {
+			url,
+			headers: () => {
+				let headers = new Headers(baseHeaders);
+
+				let accessToken = getApiKey?.();
+				if (accessToken) {
+					headers.set('Authorization', `Bearer ${accessToken}`);
+				}
+				headers = getHeaders?.(headers) ?? headers;
+				return headers;
+			},
+			plugins: resolveLinkPlugins(options),
+			fetch: options.fetch,
+		}),
+	) as JsonifiedClient<ContractRouterClient<TContract, ClientContext>>;
+}
+
+export type CreateContractClientOptions = {
+	url?: string;
+	baseUrl?: string;
+	apiKey?: string;
+	headers?: Record<string, string> | Headers;
+	getApiKey?: () => string | undefined;
+	getHeaders?: (headers: Headers) => Headers | undefined;
+	plugins?: StandardLinkPlugin<any>[];
+	fetch?: LinkFetchClientOptions<any>['fetch'];
+	batch?: BatchLinkPluginOptions<any> | boolean;
+	dedup?: DedupeRequestsPluginOptions<any> | boolean;
+};

package/src/orpc/createRpcContractClient.ts

@@ -0,0 +1,50 @@
+import { createORPCClient } from '@orpc/client';
+import { RPCLink } from '@orpc/client/fetch';
+import type { AnyContractRouter, ContractRouterClient } from '@orpc/contract';
+import { buildBaseUrl } from '../utils/buildBaseUrl';
+import type { CreateContractClientOptions } from './createOpenApiContractClient';
+import { resolveLinkPlugins } from './resolveLinkPlugins';
+
+export type CreateRpcContractClientOptions = CreateContractClientOptions;
+
+export function createRpcContractClient<C extends AnyContractRouter>(
+	options: CreateRpcContractClientOptions = {},
+): ContractRouterClient<C> {
+	let {
+		url = '/api/rpc',
+		baseUrl = globalThis.location?.origin || 'http://localhost',
+		apiKey,
+		getApiKey,
+		getHeaders,
+	} = options;
+	url = buildBaseUrl(url, baseUrl);
+
+	const baseHeaders = new Headers(options.headers);
+	if (apiKey) {
+		baseHeaders.set('Authorization', `Bearer ${apiKey}`);
+	}
+
+	const plugins = resolveLinkPlugins({
+		dedup: true,
+		batch: true,
+		...options,
+	});
+	const link = new RPCLink({
+		url,
+		headers: () => {
+			let headers = new Headers(baseHeaders);
+
+			let accessToken = getApiKey?.();
+			if (accessToken) {
+				headers.set('Authorization', `Bearer ${accessToken}`);
+			}
+			headers = getHeaders?.(headers) ?? headers;
+			return headers;
+		},
+		fetch: options.fetch,
+		plugins,
+	});
+
+	const client: ContractRouterClient<C> = createORPCClient(link);
+	return client;
+}

package/src/orpc/index.ts

@@ -0,0 +1,2 @@
+export { createRpcContractClient } from './createRpcContractClient';
+export { createOpenApiContractClient } from './createOpenApiContractClient';

package/src/orpc/resolveLinkPlugins.ts

@@ -0,0 +1,29 @@
+import { BatchLinkPlugin, DedupeRequestsPlugin } from '@orpc/client/plugins';
+import { resolveFeatureOptions } from '../utils/resolveFeatureOptions';
+import type { CreateRpcContractClientOptions } from './createRpcContractClient';
+
+export function resolveLinkPlugins({ plugins = [], dedup, batch }: CreateRpcContractClientOptions) {
+	batch = resolveFeatureOptions(batch, {
+		groups: [
+			{
+				condition: () => true,
+				context: {},
+			},
+		],
+	});
+	if (batch) {
+		plugins.push(new BatchLinkPlugin(batch));
+	}
+	dedup = resolveFeatureOptions(dedup, {
+		groups: [
+			{
+				condition: () => true,
+				context: {},
+			},
+		],
+	});
+	if (dedup) {
+		plugins.push(new DedupeRequestsPlugin(dedup));
+	}
+	return plugins;
+}

package/src/password/PHC.ts

@@ -99,11 +99,11 @@ export namespace PHC {
 
 			// Convert Numbers into Numeric Strings and Buffers into B64 encoded strings.
 			pk.forEach((k) => {
-				const value = opts.params![k];
+				const value = opts.params?.[k];
 				if (typeof value === 'number') {
 					opts.params![k] = value.toString();
 				} else if (value instanceof Uint8Array) {
-					opts.params![k] = toBase64(value).split('=')[0];
+					opts.params![k] = toBase64(value as BufferSource).split('=')[0];
 				}
 			});
 			const pv = objectValues(opts.params);
@@ -125,7 +125,7 @@ export namespace PHC {
 				throw new TypeError('salt must be a Buffer');
 			}
 
-			fields.push(toBase64(opts.salt).split('=')[0]);
+			fields.push(toBase64(opts.salt as BufferSource).split('=')[0]);
 
 			if (typeof opts.hash !== 'undefined') {
 				// Hash Validation
@@ -133,7 +133,7 @@ export namespace PHC {
 					throw new TypeError('hash must be a Buffer');
 				}
 
-				fields.push(toBase64(opts.hash).split('=')[0]);
+				fields.push(toBase64(opts.hash as BufferSource).split('=')[0]);
 			}
 		}
 
@@ -143,7 +143,7 @@ export namespace PHC {
 		return phcstr;
 	}
 
-	interface DeserializeResult {
+	export interface DeserializeResult {
 		id: string;
 		version?: number;
 		params?: Record<string, string | number>;
@@ -223,7 +223,7 @@ export namespace PHC {
 
 				// Convert Decimal Strings into Numbers
 				Object.keys(params).forEach((k) => {
-					const value = params![k];
+					const value = params?.[k];
 					if (typeof value === 'string' && decimalRegex.test(value)) {
 						params![k] = parseInt(value, 10);
 					}

package/src/password/Password.test.ts

@@ -28,7 +28,7 @@ describe('Password', () => {
 
 		await check({ algorithm: '5' });
 		await check({ algorithm: '6' });
-		await check({ algorithm: '7' });
+		// await check({ algorithm: '7' });
 	});
 
 	test('should verify manual created hash', async () => {

package/src/password/createArgon2PasswordAlgorithm.ts

@@ -1,5 +1,5 @@
 import { maybeFunction, type MaybeFunction, type MaybePromise } from '@wener/utils';
-import { Password } from './Password';
+import type { Password } from './Password';
 
 type Provide = {
 	hash: (password: string, options: { salt?: Buffer; raw?: boolean; type?: 0 | 1 | 2 }) => Promise<string>;

package/src/password/createBase64PasswordAlgorithm.ts

@@ -1,5 +1,5 @@
 import { ArrayBuffers } from '@wener/utils';
-import { Password } from './Password';
+import type { Password } from './Password';
 
 export function createBase64PasswordAlgorithm({ id = 'base64' }: { id?: string } = {}): Password.PasswordAlgorithm {
 	return {
@@ -7,7 +7,7 @@ export function createBase64PasswordAlgorithm({ id = 'base64' }: { id?: string }
 		async hash(password: string) {
 			return `$${id}$$${ArrayBuffers.toBase64(password).replace(/=/g, '')}`;
 		},
-		async verify(password: string, hash: string, opts) {
+		async verify(password: string, _hash: string, opts) {
 			return Boolean(opts.hash) && ArrayBuffers.toString(opts.hash!) === password;
 		},
 	};

package/src/password/createBcryptPasswordAlgorithm.ts

@@ -1,5 +1,5 @@
 import type { MaybePromise } from '@wener/utils';
-import { Password } from './Password';
+import type { Password } from './Password';
 
 type ProviderType = () => MaybePromise<{
 	hash: (password: string, rounds: number | string) => Promise<string>;
@@ -9,7 +9,9 @@ type ProviderType = () => MaybePromise<{
 export function createBcryptPasswordAlgorithm({
 	// provider = () => import('bcrypt').then((v) => v.default),
 	provider = () => import('bcryptjs').then((v) => v.default),
-}: { provider?: ProviderType } = {}): Password.PasswordAlgorithm {
+}: {
+	provider?: ProviderType;
+} = {}): Password.PasswordAlgorithm {
 	// bcrypt or bcryptjs
 	return {
 		name: 'bcrypt',

package/src/password/createPBKDF2PasswordAlgorithm.ts

@@ -1,5 +1,5 @@
 import { Errors } from '@wener/utils';
-import { Password } from './Password';
+import type { Password } from './Password';
 import { PHC } from './PHC';
 
 export function createPBKDF2PasswordAlgorithm({
@@ -33,7 +33,7 @@ export function createPBKDF2PasswordAlgorithm({
 				'deriveBits',
 			]);
 			let hash = await crypto.subtle.deriveBits(
-				{ name: 'PBKDF2', iterations: rounds, salt, hash: digest },
+				{ name: 'PBKDF2', iterations: rounds, salt: salt as BufferSource, hash: digest },
 				key,
 				keylen * 8,
 			);
@@ -51,11 +51,11 @@ export function createPBKDF2PasswordAlgorithm({
 				'deriveBits',
 			]);
 			let hash = await crypto.subtle.deriveBits(
-				{ name: 'PBKDF2', iterations: rounds, salt, hash: digest },
+				{ name: 'PBKDF2', iterations: rounds, salt: salt as BufferSource, hash: digest },
 				key,
 				storedHash.length * 8,
 			);
-			return new Uint8Array(hash).every((v, i) => v === storedHash![i]);
+			return new Uint8Array(hash).every((v, i) => v === storedHash?.[i]);
 		},
 	};
 }

package/src/password/createScryptPasswordAlgorithm.ts

@@ -1,6 +1,6 @@
 import { randomBytes, scrypt, timingSafeEqual } from 'node:crypto';
 import { Errors } from '@wener/utils';
-import { Password } from './Password';
+import type { Password } from './Password';
 import { PHC } from './PHC';
 
 export function createScryptPasswordAlgorithm(
@@ -14,7 +14,7 @@ export function createScryptPasswordAlgorithm(
 	} = {},
 ): Password.PasswordAlgorithm {
 	let id = options.id || 'scrypt';
-	options.cost ||= Math.pow(2, 14);
+	options.cost ||= 2 ** 14;
 	options.blocksize ||= 8;
 	options.parallelism ||= 1;
 	options.saltlen ||= 16;
@@ -35,7 +35,7 @@ export function createScryptPasswordAlgorithm(
 			});
 		},
 
-		async verify(password: string, hash: string, opts): Promise<boolean> {
+		async verify(password: string, _hash: string, opts): Promise<boolean> {
 			try {
 				const salt = Errors.BadRequest.require(opts.salt);
 				const storedHash = Errors.BadRequest.require(opts.hash);
@@ -53,7 +53,7 @@ export function createScryptPasswordAlgorithm(
 						resolve(isMatch);
 					});
 				});
-			} catch (error) {
+			} catch (_error) {
 				return Promise.resolve(false);
 			}
 		},

package/src/resource/ListQuery.ts

@@ -25,7 +25,10 @@ export const ListQuerySchema = z.object({
 	deleted: z.coerce.boolean().optional(),
 });
 
-type ListQueryOverride = ListQueryInput | undefined | ((input: ListQueryInput) => ListQueryInput | undefined | void);
+type ListQueryOverride =
+	| ListQueryInput
+	| undefined
+	| ((input: ListQueryInput) => ListQueryInput | undefined | undefined);
 
 export function resolveListQuery(target: ListQueryInput | undefined, ...args: ListQueryOverride[]): ListQuery {
 	let out = args.reduce((a: ListQueryInput, source) => {

package/src/resource/index.ts

@@ -1,4 +1,4 @@
-export { type AnyResource } from './schema/AnyResourceSchema';
-export { type Identifiable } from './Identifiable';
+export type { AnyResource } from './schema/AnyResourceSchema';
+export type { Identifiable } from './Identifiable';
 export { getTitleOfResource } from './getTitleOfResource';
 export { type ListQueryInput, type ListQuery, resolveListQuery, ListQuerySchema } from './ListQuery';

package/src/resource/schema/AnyResourceSchema.ts

@@ -2,9 +2,23 @@ import { z } from 'zod/v4';
 import { SexTypeSchema } from '../../foundation/schema/SexType';
 import { rz } from './types';
 
-export type AnyResource = z.infer<typeof AnyResourceSchema>;
+export type AnyResource = z.infer<typeof AnyResourceSchema> & {
+	owner?: AnyResource;
+
+	entity?: AnyResource;
+
+	customer?: AnyResource;
+	account?: AnyResource;
+	contact?: AnyResource;
+
+	user?: AnyResource;
+	createdBy?: AnyResource;
+	updatedBy?: AnyResource;
+	deletedBy?: AnyResource;
+};
+
 export const AnyResourceSchema = z
-	.object({
+	.looseObject({
 		id: rz.resourceId.readonly().describe('ID'),
 		uid: z.guid().nullish().readonly().describe('唯一ID'),
 		tid: rz.resourceId.nullish().readonly().describe('租户ID'),

package/src/s3/formatS3Url.test.ts

@@ -0,0 +1,254 @@
+import { describe, expect, it } from 'vitest';
+import { formatS3Url } from './formatS3Url';
+import type { ParsedS3Options } from './parseS3Url';
+
+describe('formatS3Url', () => {
+	it('should format basic S3 URL with default endpoint', () => {
+		const options: ParsedS3Options = {
+			endpoint: 's3.amazonaws.com',
+		};
+		const result = formatS3Url(options);
+		expect(result).toBe('https://s3.amazonaws.com/');
+	});
+
+	it('should format S3 URL with custom endpoint', () => {
+		const options: ParsedS3Options = {
+			endpoint: 'custom-s3.com',
+		};
+		const result = formatS3Url(options);
+		expect(result).toBe('https://custom-s3.com/');
+	});
+
+	it('should format S3 URL with HTTP protocol', () => {
+		const options: ParsedS3Options = {
+			endpoint: 's3.amazonaws.com',
+			useSsl: false,
+		};
+		const result = formatS3Url(options);
+		expect(result).toBe('http://s3.amazonaws.com/');
+	});
+
+	it('should format S3 URL with port', () => {
+		const options: ParsedS3Options = {
+			endpoint: 's3.amazonaws.com',
+			port: 9000,
+		};
+		const result = formatS3Url(options);
+		expect(result).toBe('https://s3.amazonaws.com:9000/');
+	});
+
+	it('should format S3 URL with bucket in path style', () => {
+		const options: ParsedS3Options = {
+			endpoint: 's3.amazonaws.com',
+			bucket: 'my-bucket',
+			pathStyle: true,
+		};
+		const result = formatS3Url(options);
+		expect(result).toBe('https://s3.amazonaws.com/my-bucket/');
+	});
+
+	it('should format S3 URL with bucket in virtual hosted style', () => {
+		const options: ParsedS3Options = {
+			endpoint: 's3.amazonaws.com',
+			bucket: 'my-bucket',
+			pathStyle: false,
+		};
+		const result = formatS3Url(options);
+		expect(result).toBe('https://my-bucket.s3.amazonaws.com/');
+	});
+
+	it('should format S3 URL with credentials', () => {
+		const options: ParsedS3Options = {
+			endpoint: 's3.amazonaws.com',
+			accessKeyId: 'user',
+			secretAccessKey: 'pass',
+		};
+		const result = formatS3Url(options, { credentials: true });
+		expect(result).toBe('https://user:pass@s3.amazonaws.com/');
+	});
+
+	it('should format S3 URL with credentials and special characters', () => {
+		const options: ParsedS3Options = {
+			endpoint: 's3.amazonaws.com',
+			accessKeyId: 'user@example.com',
+			secretAccessKey: 'pass/word',
+		};
+		const 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', () => {
+		const options: ParsedS3Options = {
+			endpoint: 's3.amazonaws.com',
+			region: 'us-east-1',
+		};
+		const 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', () => {
+		const options: ParsedS3Options = {
+			endpoint: 's3.amazonaws.com',
+			pathStyle: true,
+		};
+		const result = formatS3Url(options, { useParams: true });
+		expect(result).toBe('https://s3.amazonaws.com/?pathStyle=true');
+	});
+
+	it('should format S3 URL with all parameters', () => {
+		const options: ParsedS3Options = {
+			endpoint: 's3.amazonaws.com',
+			accessKeyId: 'user',
+			secretAccessKey: 'pass',
+			region: 'us-east-1',
+			port: 9000,
+			bucket: 'my-bucket',
+			pathStyle: true,
+			useSsl: true,
+		};
+		const 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', () => {
+		const options: ParsedS3Options = {
+			endpoint: 'https://custom-s3.com:9000',
+			bucket: 'my-bucket',
+			pathStyle: true,
+		};
+		const 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', () => {
+		const options: ParsedS3Options = {
+			endpoint: 'my-bucket.s3.amazonaws.com',
+			bucket: 'my-bucket',
+			pathStyle: false,
+		};
+		const result = formatS3Url(options);
+		expect(result).toBe('https://my-bucket.s3.amazonaws.com/');
+	});
+
+	it('should throw error for missing endpoint', () => {
+		const options = {} as ParsedS3Options;
+		expect(() => formatS3Url(options)).toThrow('Endpoint is required');
+	});
+
+	it('should handle endpoint without protocol by adding https://', () => {
+		const options: ParsedS3Options = {
+			endpoint: 'custom-s3.com',
+		};
+		const result = formatS3Url(options);
+		expect(result).toBe('https://custom-s3.com/');
+	});
+
+	it('should throw error for missing credentials when credentials=true', () => {
+		const options: ParsedS3Options = {
+			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', () => {
+		const options: ParsedS3Options = {
+			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', () => {
+		const options: ParsedS3Options = {
+			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', () => {
+		const options: ParsedS3Options = {
+			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', () => {
+		const options: ParsedS3Options = {
+			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', () => {
+		const options: ParsedS3Options = {
+			endpoint: 's3.amazonaws.com',
+			bucket: 'mybucket-',
+		};
+		expect(() => formatS3Url(options)).toThrow('Invalid bucket name: mybucket-');
+	});
+
+	it('should handle bucket name with dot-hyphen (currently allowed)', () => {
+		const options: ParsedS3Options = {
+			endpoint: 's3.amazonaws.com',
+			bucket: 'my.bucket-name',
+			pathStyle: true,
+		};
+		const result = formatS3Url(options);
+		expect(result).toBe('https://s3.amazonaws.com/my.bucket-name/');
+	});
+
+	it('should throw error for bucket name that is too short', () => {
+		const options: ParsedS3Options = {
+			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', () => {
+		const options: ParsedS3Options = {
+			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', () => {
+		const validBuckets = ['my-bucket', 'my.bucket', 'mybucket123', '123bucket', 'test-bucket-123'];
+
+		validBuckets.forEach((bucket) => {
+			const options: ParsedS3Options = {
+				endpoint: 's3.amazonaws.com',
+				bucket,
+				pathStyle: true,
+			};
+			expect(() => formatS3Url(options)).not.toThrow();
+		});
+	});
+
+	it('should handle pathname concatenation correctly in path style', () => {
+		const options: ParsedS3Options = {
+			endpoint: 'https://s3.amazonaws.com/path/to/something',
+			bucket: 'my-bucket',
+			pathStyle: true,
+		};
+		const 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', () => {
+		const options: ParsedS3Options = {
+			endpoint: 'https://s3.amazonaws.com/path/to/something',
+			bucket: 'my-bucket',
+			pathStyle: false,
+		};
+		const result = formatS3Url(options);
+		expect(result).toBe('https://my-bucket.s3.amazonaws.com/path/to/something');
+	});
+});