@wener/common 2.0.1 → 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/Password.ts

@@ -68,10 +68,10 @@ export namespace Password {
 		return f;
 	}
 
-	export async function check(password: string, hash: string) {
+	export async function validate(password: string, hash: string) {
 		let res = await parse(hash);
 		let f = resolveAlgorithm(res.id);
-		return { result: f.verify(password, hash, res), parsed: res };
+		return { result: await f.verify(password, hash, res), parsed: res };
 	}
 
 	export async function verify(password: string, hash: string) {

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

@@ -0,0 +1,53 @@
+import { z } from 'zod/v4';
+
+export type ListQueryInput = z.input<typeof ListQuerySchema>;
+export type ListQuery = z.infer<typeof ListQuerySchema>;
+const IntLikeSchema = z.coerce
+	.number()
+	.multipleOf(1)
+	.min(0)
+	.optional()
+	.overwrite((v) => v || undefined);
+export const ListQuerySchema = z.object({
+	id: z.coerce.string().optional(),
+	ids: z.array(z.coerce.string()).optional(),
+	filter: z.string().optional().describe('sql-like filter string'),
+	filters: z.array(z.any()).optional().describe('sql-like filter string'),
+	where: z.record(z.string(), z.any()).optional().describe('document query filter'),
+	search: z.string().optional(),
+	limit: IntLikeSchema,
+	offset: IntLikeSchema,
+	order: z.array(z.string()).optional().describe('order like "a,-b,c desc null last"'),
+	pageIndex: IntLikeSchema.describe('0-based page index'),
+	pageNumber: IntLikeSchema.describe('1-based page number'),
+	pageSize: IntLikeSchema,
+	cursor: z.string().optional(),
+	deleted: z.coerce.boolean().optional(),
+});
+
+type ListQueryOverride = ListQueryInput | undefined | ((input: ListQueryInput) => ListQueryInput | undefined | void);
+
+export function resolveListQuery(target: ListQueryInput | undefined, ...args: ListQueryOverride[]): ListQuery {
+	let out = args.reduce((a: ListQueryInput, source) => {
+		if (typeof source === 'function') {
+			const result = source(a);
+			// do not use the result as merge source
+			return result || a;
+		}
+
+		let b: ListQueryInput | undefined = source;
+		if (!b) return a;
+
+		// do not resolve id to ids
+		let ids = [...(a.ids || []), ...(b.ids || [])];
+		return {
+			...a,
+			...b,
+			ids: ids,
+			filters: [...(a.filters || []), ...(b.filters || [])],
+			search: b.search || a.search,
+			// NOTE maybe should merge where ?
+		};
+	}, target || {});
+	return ListQuerySchema.parse(out);
+}

package/src/resource/index.ts

@@ -1,3 +1,4 @@
 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

@@ -1,10 +1,24 @@
 import { z } from 'zod/v4';
-import { SexTypeSchema } from './SexType';
+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/resource/schema/index.ts

@@ -0,0 +1,5 @@
+export { ResourceStatus, ResourceStatusSchema } from './ResourceStatus';
+export { ResourceActionType, ResourceActionTypeSchema, ResourceActionDataSchema } from './ResourceActionType';
+export { AnyResourceSchema, type AnyResource } from './AnyResourceSchema';
+export { rz, type EnumValues } from './types';
+export { BaseResourceSchema } from './BaseResourceSchema';

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