@wener/common 2.0.2 → 2.0.3

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/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 | void;
+	getHeaders?: (headers: Headers) => Headers | void;
+	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

@@ -103,7 +103,7 @@ export namespace PHC {
 				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]);
 			}
 		}
 

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/createPBKDF2PasswordAlgorithm.ts

@@ -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,7 +51,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,
 				storedHash.length * 8,
 			);

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');
+	});
+});

package/src/s3/formatS3Url.ts

@@ -0,0 +1,84 @@
+import type { ParsedS3Options } from './parseS3Url';
+
+function isValidBucketName(bucket: string): boolean {
+	const bucketRegex = /^[a-z0-9][a-z0-9.-]{1,61}[a-z0-9]$/;
+	return bucketRegex.test(bucket) && !bucket.includes('..') && !bucket.includes('.-') && !bucket.includes('-.');
+}
+
+export function formatS3Url(
+	o: ParsedS3Options,
+	{
+		credentials,
+		useParams,
+	}: {
+		credentials?: boolean;
+		useParams?: boolean;
+	} = {},
+): string {
+	if (!o || typeof o !== 'object') {
+		throw new Error('S3 options must be an object');
+	}
+
+	if (!o.endpoint) {
+		throw new Error('Endpoint is required');
+	}
+
+	let url: URL;
+	let ep = o.endpoint || 's3.amazonaws.com';
+	try {
+		if (URL.canParse(ep)) {
+			url = new URL(ep);
+		} else {
+			url = new URL(`https://${ep}`);
+		}
+	} catch (error) {
+		throw new Error(`Invalid endpoint: ${ep}`);
+	}
+
+	const { useSsl = true, region, pathStyle, port, accessKeyId, secretAccessKey, bucket } = o;
+	url.protocol = useSsl ? 'https:' : 'http:';
+
+	if (credentials) {
+		if (accessKeyId && secretAccessKey) {
+			url.username = encodeURIComponent(accessKeyId);
+			url.password = encodeURIComponent(secretAccessKey);
+		} else {
+			throw new Error('Access Key ID and Secret Access Key are required for credentials');
+		}
+	}
+
+	if (useParams) {
+		if (region) {
+			url.searchParams.set('region', region);
+		}
+		if (pathStyle !== undefined) {
+			url.searchParams.set('pathStyle', String(pathStyle));
+		}
+	}
+
+	if (port) {
+		const portNum = Number(port);
+		if (isNaN(portNum) || portNum < 1 || portNum > 65535) {
+			throw new Error('Port must be a valid number between 1 and 65535');
+		}
+		url.port = String(portNum);
+	}
+
+	if (bucket) {
+		if (!isValidBucketName(bucket)) {
+			throw new Error(`Invalid bucket name: ${bucket}`);
+		}
+
+		if (pathStyle) {
+			url.pathname = `/${bucket}${url.pathname}`;
+		} else {
+			// Check if bucket is already in hostname (virtual-hosted style)
+			const bucketPattern = new RegExp(`^${bucket.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\.`);
+			if (!bucketPattern.test(url.hostname)) {
+				url.hostname = `${bucket}.${url.hostname}`;
+			}
+		}
+	}
+
+	return url.toString();
+}

package/src/s3/index.ts

@@ -0,0 +1,2 @@
+export { parseS3Url, type ParseS3UrlOptions } from './parseS3Url';
+export { formatS3Url } from './formatS3Url';