@wener/common 2.0.3 → 2.0.5

package/src/fs/tests/runFileSystemTest.ts

@@ -1,6 +1,6 @@
 import { expect } from 'vitest';
 import { FileSystemError, FileSystemErrorCode } from '../FileSystemError';
-import type { IFileSystem } from '../IFileSystem';
+import type { IFileSystem, IServerFileSystem } from '../IFileSystem';
 
 export type RunFileSystemTestOptions = {
 	writableStream?: boolean;
@@ -10,7 +10,7 @@ export type RunFileSystemTestOptions = {
 	abort?: boolean;
 };
 
-export async function runFileSystemTest(fs: IFileSystem, options: RunFileSystemTestOptions = {}) {
+export async function runFileSystemTest(fs: IFileSystem | IServerFileSystem, options: RunFileSystemTestOptions = {}) {
 	const { writableStream = true, readableStream = true, readStream = true, writeStream = true, abort = true } = options;
 	// should be implemented
 	const stat = await fs.stat('/README.txt');
@@ -65,21 +65,22 @@ export async function runFileSystemTest(fs: IFileSystem, options: RunFileSystemT
 	await expect(fs.writeFile('/', 'test')).rejects.toMatchObject({ code: FileSystemErrorCode.EINVAL });
 
 	// should support streaming operations
-	if (readStream && fs.createReadStream) {
+	const serverFs = fs as IServerFileSystem;
+	if (readStream && 'createReadStream' in fs) {
 		await fs.writeFile('/stream.txt', 'Hello, World!');
 
 		// Test createReadStream
-		const readStream = fs.createReadStream('/stream.txt');
-		expect(readStream).toBeDefined();
+		const readStreamObj = serverFs.createReadStream('/stream.txt');
+		expect(readStreamObj).toBeDefined();
 
 		const chunks: Buffer[] = [];
-		for await (const chunk of readStream) {
+		for await (const chunk of readStreamObj) {
 			chunks.push(chunk);
 		}
 		expect(Buffer.concat(chunks).toString()).toBe('Hello, World!');
 
 		// Test createReadStream with range
-		const rangeStream = fs.createReadStream('/stream.txt', { range: { start: 0, end: 4 } });
+		const rangeStream = serverFs.createReadStream('/stream.txt', { range: { start: 0, end: 4 } });
 		const rangeChunks: Buffer[] = [];
 		for await (const chunk of rangeStream) {
 			rangeChunks.push(chunk);
@@ -87,37 +88,37 @@ export async function runFileSystemTest(fs: IFileSystem, options: RunFileSystemT
 		expect(Buffer.concat(rangeChunks).toString()).toBe('Hello');
 	}
 
-	if (writeStream && fs.createWriteStream) {
+	if (writeStream && 'createWriteStream' in fs) {
 		// Test createWriteStream
-		const writeStream = fs.createWriteStream('/write-test.txt');
-		expect(writeStream).toBeDefined();
+		const writeStreamObj = serverFs.createWriteStream('/write-test.txt');
+		expect(writeStreamObj).toBeDefined();
 
-		writeStream.write('Test content');
-		writeStream.end();
+		writeStreamObj.write('Test content');
+		writeStreamObj.end();
 
-		await new Promise((resolve) => writeStream.on('finish', resolve));
+		await new Promise((resolve) => writeStreamObj.on('finish', resolve));
 		expect(await fs.readFile('/write-test.txt', { encoding: 'text' })).toBe('Test content');
 	}
 
 	// should support Web Streams API
-	if (readableStream) {
+	if (readableStream && fs.createReadableStream) {
 		await fs.writeFile('/webstream.txt', 'Web Stream Test');
 
 		// Test createReadableStream
-		const readableStream = fs.createReadableStream('/webstream.txt');
-		expect(readableStream).toBeDefined();
+		const readableStreamObj = fs.createReadableStream('/webstream.txt');
+		expect(readableStreamObj).toBeDefined();
 
-		const reader = readableStream.getReader();
+		const reader = readableStreamObj.getReader();
 		const { value } = await reader.read();
 		expect(value?.toString()).toBe('Web Stream Test');
 	}
 
-	if (writableStream) {
+	if (writableStream && fs.createWritableStream) {
 		// Test createWritableStream
-		const writableStream = fs.createWritableStream('/web-write-test.txt');
-		expect(writableStream).toBeDefined();
+		const writableStreamObj = fs.createWritableStream('/web-write-test.txt');
+		expect(writableStreamObj).toBeDefined();
 
-		const writer = writableStream.getWriter();
+		const writer = writableStreamObj.getWriter();
 		await writer.write(Buffer.from('Web Stream Write Test'));
 		await writer.close();
 
@@ -125,30 +126,30 @@ export async function runFileSystemTest(fs: IFileSystem, options: RunFileSystemT
 	}
 
 	// should handle streaming errors
-	if (abort && readStream && fs.createReadStream) {
+	if (abort && readStream && 'createReadStream' in fs) {
 		const controller2 = new AbortController();
 
 		// Test read stream with abort
-		const readStream = fs.createReadStream('/README.txt', { signal: controller2.signal });
+		const readStreamObj = serverFs.createReadStream('/README.txt', { signal: controller2.signal });
 		controller2.abort();
 
 		await expect(
 			new Promise((_, reject) => {
-				readStream.on('error', reject);
+				readStreamObj.on('error', reject);
 			}),
 		).rejects.toThrow(Error);
 	}
 
-	if (abort && writeStream && fs.createWriteStream) {
+	if (abort && writeStream && 'createWriteStream' in fs) {
 		// Test write stream with abort
 		const controller3 = new AbortController();
-		const writeStream = fs.createWriteStream('/abort-test.txt', { signal: controller3.signal });
+		const writeStreamObj = serverFs.createWriteStream('/abort-test.txt', { signal: controller3.signal });
 		controller3.abort();
 
 		await expect(
 			new Promise((_, reject) => {
-				writeStream.on('error', reject);
-				writeStream.write('test');
+				writeStreamObj.on('error', reject);
+				writeStreamObj.write('test');
 			}),
 		).rejects.toThrow(Error);
 	}

package/src/fs/utils.ts

@@ -4,7 +4,7 @@ import type { IFileStat, WritableData } from './IFileSystem';
 export function resolveData(data: WritableData) {
 	let buf: Uint8Array;
 	if (typeof data === 'string') {
-		buf = ArrayBuffers.toUint8Array(ArrayBuffers.from(data, 'utf8'));
+		buf = ArrayBuffers.toUint8Array(ArrayBuffers.from(data, 'utf8') as BufferSource);
 	} else if (data instanceof ArrayBuffer) {
 		buf = new Uint8Array(data);
 	} else if (data instanceof Uint8Array) {

package/src/fs/webdav/index.ts

@@ -0,0 +1 @@
+export { createWebDavFileSystem } from '../createWebDavFileSystem';

package/src/jsonschema/JsonSchema.ts

@@ -72,7 +72,7 @@ function addSchema(
 			onConflict = (_, neo) => neo;
 			break;
 		case 'throw':
-			onConflict = (old, neo) => {
+			onConflict = (_old, neo) => {
 				throw new Error(`Schema ${neo.$id} already exists`);
 			};
 			break;
@@ -119,8 +119,8 @@ function create<S>(schema: S, data?: any): TypeOfSchema<S> {
 		.with({ oneOf: P.nonNullable }, (schema) => {
 			return create(schema.oneOf[0]);
 		})
-		.with({ type: 'string' }, (schema) => '')
-		.with({ type: P.union('number', 'integer') }, (schema) => 0)
+		.with({ type: 'string' }, (_schema) => '')
+		.with({ type: P.union('number', 'integer') }, (_schema) => 0)
 		.with({ type: 'object' }, (schema: JsonSchemaDef) => {
 			let out = validate({ schema, data: data ?? {}, mutate: true });
 			if (!out.success) {
@@ -141,8 +141,8 @@ function create<S>(schema: S, data?: any): TypeOfSchema<S> {
 			return out.data;
 		})
 		.with({ type: 'null' }, () => null)
-		.with({ type: 'boolean' }, (schema) => false)
-		.with({ type: 'array' }, (schema) => [])
+		.with({ type: 'boolean' }, (_schema) => false)
+		.with({ type: 'array' }, (_schema) => [])
 		.otherwise(() => {
 			return undefined;
 		});

package/src/jsonschema/forEachJsonSchema.ts

@@ -9,7 +9,7 @@ export function forEachJsonSchema(js: JsonSchemaDef, cb: (js: JsonSchemaDef, ctx
 		_f: (js: JsonSchemaDef, ctx: VisitJsonSchemaContext) => void,
 		parent: JsonSchemaDef | undefined,
 		path: string[],
-		k?: string,
+		_k?: string,
 	) => {
 		if (!js) {
 			return;

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

@@ -43,8 +43,8 @@ export type CreateContractClientOptions = {
 	baseUrl?: string;
 	apiKey?: string;
 	headers?: Record<string, string> | Headers;
-	getApiKey?: () => string | void;
-	getHeaders?: (headers: Headers) => Headers | void;
+	getApiKey?: () => string | undefined;
+	getHeaders?: (headers: Headers) => Headers | undefined;
 	plugins?: StandardLinkPlugin<any>[];
 	fetch?: LinkFetchClientOptions<any>['fetch'];
 	batch?: BatchLinkPluginOptions<any> | boolean;

package/src/password/PHC.ts

@@ -99,7 +99,7 @@ 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) {
@@ -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/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({
@@ -55,7 +55,7 @@ export function createPBKDF2PasswordAlgorithm({
 				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/s3/formatS3Url.test.ts

@@ -216,7 +216,7 @@ describe('formatS3Url', () => {
 			endpoint: 's3.amazonaws.com',
 			bucket: 'a'.repeat(64),
 		};
-		expect(() => formatS3Url(options)).toThrow('Invalid bucket name: ' + 'a'.repeat(64));
+		expect(() => formatS3Url(options)).toThrow(`Invalid bucket name: ${'a'.repeat(64)}`);
 	});
 
 	it('should handle valid bucket names with various formats', () => {

package/src/s3/formatS3Url.ts

@@ -31,7 +31,7 @@ export function formatS3Url(
 		} else {
 			url = new URL(`https://${ep}`);
 		}
-	} catch (error) {
+	} catch (_error) {
 		throw new Error(`Invalid endpoint: ${ep}`);
 	}
 
@@ -58,7 +58,7 @@ export function formatS3Url(
 
 	if (port) {
 		const portNum = Number(port);
-		if (isNaN(portNum) || portNum < 1 || portNum > 65535) {
+		if (Number.isNaN(portNum) || portNum < 1 || portNum > 65535) {
 			throw new Error('Port must be a valid number between 1 and 65535');
 		}
 		url.port = String(portNum);

package/src/s3/parseS3Url.ts

@@ -27,7 +27,7 @@ export function parseS3Url({ url = process.env.S3_URL, ...rest }: ParseS3UrlOpti
 	let parsed: URL;
 	try {
 		parsed = new URL(normalizedUrl);
-	} catch (error) {
+	} catch (_error) {
 		throw new Error(`Invalid S3 URL: ${url}`);
 	}
 

package/src/schema/SchemaRegistry.ts

@@ -21,7 +21,7 @@ export namespace SchemaRegistry {
 	}
 
 	function getKey(s: TypeSchema | string) {
-		let key;
+		let key: string | undefined;
 		if (typeof s === 'string') {
 			key = s;
 		} else {

package/src/schema/TypeSchema.d.ts

@@ -10,23 +10,23 @@ import type { JsonSchemaDef } from '../jsonschema';
 export type TypeSchema<I = unknown, O = I> = TSchema | z.ZodSchema<O, I> | JsonSchemaDef | StandardSchemaV1<I, O>;
 
 export type SchemaOutput<S extends TypeSchema> =
-	S extends StandardSchemaV1<infer I, infer O>
+	S extends StandardSchemaV1<infer _I, infer O>
 		? O
-		: S extends z.ZodSchema<infer O, infer I>
+		: S extends z.ZodSchema<infer O, infer _I>
 			? O
 			: S extends TSchema
 				? TypeBoxStaticEncode<S>
-				: S extends JsonSchemaDef<infer I, infer O>
+				: S extends JsonSchemaDef<infer _I, infer O>
 					? O
 					: never;
 
 export type SchemaInput<S extends TypeSchema> =
-	S extends StandardSchemaV1<infer I, infer O>
+	S extends StandardSchemaV1<infer I, infer _O>
 		? I
-		: S extends z.ZodSchema<infer O, infer I>
+		: S extends z.ZodSchema<infer _O, infer I>
 			? I
 			: S extends TSchema
 				? TypeBoxStaticDecode<S>
-				: S extends JsonSchemaDef<infer I, infer O>
+				: S extends JsonSchemaDef<infer I, infer _O>
 					? I
 					: never;

package/src/schema/createSchemaData.ts

@@ -54,8 +54,8 @@ function _create(schema: JsonSchemaDef, options: CreateOptions, ctx: { required:
 		.with({ oneOf: P.nonNullable }, (schema) => {
 			return _create(schema.oneOf[0], options, { required: false });
 		})
-		.with({ type: 'string' }, (schema) => '')
-		.with({ type: P.union('number', 'integer') }, (schema) => 0)
+		.with({ type: 'string' }, (_schema) => '')
+		.with({ type: P.union('number', 'integer') }, (_schema) => 0)
 		.with({ type: 'object' }, () => {
 			const out: Record<string, any> = {};
 
@@ -73,8 +73,8 @@ function _create(schema: JsonSchemaDef, options: CreateOptions, ctx: { required:
 			return out;
 		})
 		.with({ type: 'null' }, () => null)
-		.with({ type: 'boolean' }, (schema) => false)
-		.with({ type: 'array' }, (schema) => [])
+		.with({ type: 'boolean' }, (_schema) => false)
+		.with({ type: 'array' }, (_schema) => [])
 		.otherwise(() => {
 			return undefined;
 		});

package/src/schema/findJsonSchemaByPath.ts

@@ -14,10 +14,10 @@ export function findJsonSchemaByPath(schema: TypeSchema, objectPath: string) {
 	for (const segment of segments) {
 		// 检查当前 schema 是否是对象类型且有 properties
 		if (
-			currentSchema
-			&& typeof currentSchema === 'object'
-			&& currentSchema.properties
-			&& currentSchema.properties[segment]
+			currentSchema &&
+			typeof currentSchema === 'object' &&
+			currentSchema.properties &&
+			currentSchema.properties[segment]
 		) {
 			currentSchema = currentSchema.properties[segment];
 			continue;

package/src/schema/formatZodError.test.ts

@@ -181,10 +181,11 @@ describe('formatZodError', () => {
 
 	it('should use schema description when available', () => {
 		const schema = z.object({
-			name: z.string().describe('姓名'),
+			name: z.string().min(1).describe('姓名'),
 			email: z.string().email().describe('邮箱地址'),
 		});
 
+		// Use empty string for name (triggers min(1) error) and invalid email
 		const result = schema.safeParse({ name: '', email: 'invalid' });
 		expect(result.success).toBe(false);
 		if (!result.success) {