@wener/common 2.0.3 → 2.0.6

package/src/fs/server/loadTestDatabase.ts

@@ -1,131 +1,20 @@
-import { inspect } from 'node:util';
-import type { Options as BetterSqliteOptions } from '@mikro-orm/better-sqlite';
-import { Errors, ulid } from '@wener/utils';
-import type { Database } from 'better-sqlite3';
+import { MikroORM } from '@mikro-orm/core';
+import { SqliteDriver } from '@mikro-orm/sql';
+import { createSqliteDialect } from '../../orm/createSqliteDialect';
 import { FileNodeContentEntity, FileNodeMetaEntity } from './createDatabaseFileSystem';
 
-export async function loadTestDatabase({ options }: { options?: BetterSqliteOptions } = {}) {
-	const { MikroORM: SqliteMikroORM } = await import('@mikro-orm/better-sqlite');
-
-	const orm = await SqliteMikroORM.init({
+export async function loadTestDatabase() {
+	const orm = await MikroORM.init({
+		driver: SqliteDriver,
 		dbName: ':memory:',
 		entities: [FileNodeContentEntity, FileNodeMetaEntity],
-		discovery: {
-			disableDynamicFileAccess: true,
-			requireEntitiesArray: true,
-		},
-		serialization: {
-			includePrimaryKeys: true,
-			forceObject: true,
-		},
-		findOneOrFailHandler(entityName, where) {
-			throw Errors.NotFound.asError(`未找到数据: ${entityName} ${inspect(where)}`);
-		},
-		findExactlyOneOrFailHandler(entityName, where) {
-			throw Errors.BadRequest.asError(`错误的数据数量: ${entityName} ${inspect(where)}`);
-		},
-		...options,
+		driverOptions: await createSqliteDialect(':memory:'),
 	});
 
-	const knex = orm.em.getKnex();
-	{
-		const db: Database = await knex.client.acquireConnection();
-		db.function('ulid', () => ulid());
-		await knex.client.releaseConnection(db);
-	}
-
-	// Execute schema creation
-	for (const stmt of FileSystemSchema.split(';')) {
-		const sql = stmt.trim();
-		if (sql) {
-			await knex.raw(sql);
-		}
-	}
+	await orm.schema.create();
 
 	return {
 		orm,
 		em: orm.em.fork(),
 	};
 }
-
-export const FileSystemSchema = `
-CREATE TABLE IF NOT EXISTS "file_node_meta"
-(
-    -- Base fields
-    "id"         TEXT PRIMARY KEY NOT NULL DEFAULT (ulid()),
-    "tid"        TEXT,
-    "uid"        TEXT,
-    "eid"        TEXT,
-    "created_at" TEXT             NOT NULL DEFAULT (datetime('now')),
-    "updated_at" TEXT             NOT NULL DEFAULT (datetime('now')),
-    "deleted_at" TEXT,
-    "attributes" TEXT,
-    "properties" TEXT,
-    "extensions" TEXT,
-
-    -- File identification
-    "filename"   TEXT             NOT NULL,
-    "size"       INTEGER          NOT NULL DEFAULT 0,
-    "kind"       TEXT             NOT NULL,
-
-    -- Timestamps
-    "atime"      TEXT             NOT NULL,
-    "btime"      TEXT             NOT NULL,
-    "ctime"      TEXT             NOT NULL,
-    "mtime"      TEXT             NOT NULL,
-
-    -- Metadata
-    "metadata"   TEXT             NOT NULL DEFAULT '{}',
-
-    -- Hierarchy
-    "parent_id"  TEXT,
-
-    -- Small file content (for files < 64KB)
-    "content"    BLOB,
-
-    FOREIGN KEY ("parent_id") REFERENCES "file_node_meta" ("id")
-);
-
-CREATE INDEX IF NOT EXISTS "idx_file_node_meta_filename" ON "file_node_meta" ("filename");
-CREATE INDEX IF NOT EXISTS "idx_file_node_meta_parent_id" ON "file_node_meta" ("parent_id");
-CREATE INDEX IF NOT EXISTS "idx_file_node_meta_tid_parent_filename" ON "file_node_meta" ("tid", "parent_id", "filename");
-
-CREATE TABLE IF NOT EXISTS "file_node_content"
-(
-    -- Base fields
-    "id"         TEXT PRIMARY KEY NOT NULL DEFAULT (ulid()),
-    "node_id"    TEXT             NOT NULL UNIQUE,
-    "tid"        TEXT,
-    "uid"        TEXT,
-    "eid"        TEXT,
-    "created_at" TEXT             NOT NULL DEFAULT (datetime('now')),
-    "updated_at" TEXT             NOT NULL DEFAULT (datetime('now')),
-    "deleted_at" TEXT,
-    "attributes" TEXT,
-    "properties" TEXT,
-    "extensions" TEXT,
-
-    -- Content information
-    "size"       INTEGER          NOT NULL,
-    "content"    BLOB,
-
-    -- File properties
-    "mime_type"  TEXT,
-
-    -- Checksums
-    "md5"        TEXT,
-    "sha256"     TEXT,
-
-    -- Content metadata
-    "text"       TEXT,
-    "width"      INTEGER,
-    "height"     INTEGER,
-
-    -- Additional metadata
-    "metadata"   TEXT             NOT NULL DEFAULT '{}',
-
-    FOREIGN KEY ("node_id") REFERENCES "file_node_meta" ("id") ON DELETE CASCADE
-);
-
-CREATE INDEX IF NOT EXISTS "idx_file_node_content_node_id" ON "file_node_content" ("node_id");
-`;

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

@@ -1,3 +1,3 @@
+export { forEachJsonSchema } from './forEachJsonSchema';
 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/meta/index.ts

@@ -1,5 +1,4 @@
-export { createMetadataKey, defineMetadata, getMetadata } from './defineMetadata';
+export { defineFileType, type FileTypeDef, getFileType } from './defineFileType';
 
 export { defineInit, type InitDef, runInit } from './defineInit';
-
-export { defineFileType, getFileType, type FileTypeDef } from './defineFileType';
+export { createMetadataKey, defineMetadata, getMetadata } from './defineMetadata';

package/src/orm/createSqliteDialect.ts

@@ -0,0 +1,17 @@
+import { NodeSqliteDialect } from '@mikro-orm/sql';
+
+/**
+ * Create a Kysely SQLite dialect based on the current runtime.
+ * - Bun: uses bun:sqlite via kysely-bun-sqlite
+ * - Node.js 22.5+: uses node:sqlite via NodeSqliteDialect
+ */
+export async function createSqliteDialect(dbName: string) {
+	if (typeof (globalThis as any).Bun !== 'undefined') {
+		// @ts-expect-error bun-only module
+		const { BunSqliteDialect } = await import('kysely-bun-sqlite');
+		// @ts-expect-error bun-only module
+		const { Database } = await import('bun:sqlite');
+		return new BunSqliteDialect({ database: new Database(dbName) });
+	}
+	return new NodeSqliteDialect(dbName);
+}

package/src/orm/index.ts

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

package/src/orpc/createOpenApiContractClient.ts

@@ -1,4 +1,4 @@
-import { createORPCClient, type ClientContext } from '@orpc/client';
+import { type ClientContext, createORPCClient } 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';
@@ -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/orpc/index.ts

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

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 MaybeFunction, type MaybePromise, maybeFunction } from '@wener/utils';
+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/password/index.ts

@@ -1,5 +1,5 @@
-export { PHC } from './PHC';
-export { Password } from './Password';
 export { createArgon2PasswordAlgorithm } from './createArgon2PasswordAlgorithm';
 export { createBase64PasswordAlgorithm } from './createBase64PasswordAlgorithm';
 export { createBcryptPasswordAlgorithm } from './createBcryptPasswordAlgorithm';
+export { Password } from './Password';
+export { PHC } from './PHC';

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 { getTitleOfResource } from './getTitleOfResource';
-export { type ListQueryInput, type ListQuery, resolveListQuery, ListQuerySchema } from './ListQuery';
+export type { Identifiable } from './Identifiable';
+export { type ListQuery, type ListQueryInput, ListQuerySchema, resolveListQuery } from './ListQuery';
+export type { AnyResource } from './schema/AnyResourceSchema';

package/src/resource/schema/index.ts

@@ -1,5 +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 { type AnyResource, AnyResourceSchema } from './AnyResourceSchema';
 export { BaseResourceSchema } from './BaseResourceSchema';
+export { ResourceActionDataSchema, ResourceActionType, ResourceActionTypeSchema } from './ResourceActionType';
+export { ResourceStatus, ResourceStatusSchema } from './ResourceStatus';
+export { type EnumValues, rz } from './types';

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

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

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

@@ -1,6 +1,6 @@
 import { getGlobalStates } from '@wener/utils';
 import type { JsonSchemaDef } from '../jsonschema';
-import { toJsonSchema, type SchemaOutput, type TypeSchema } from './index';
+import { type SchemaOutput, type TypeSchema, toJsonSchema } from './index';
 
 export namespace SchemaRegistry {
 	const types = getGlobalStates('@wener/common/resource/schema/SchemaRegistry', () => new Map<string, JsonSchemaDef>());
@@ -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 {