btca-server 1.0.962 → 2.0.1

package/src/resources/impls/npm.test.ts

@@ -3,7 +3,6 @@ import { promises as fs } from 'node:fs';
 import { mkdirSync, writeFileSync } from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
-import { Result } from 'better-result';
 
 import { loadNpmResource } from './npm.ts';
 import type { BtcaNpmResourceArgs } from '../types.ts';
@@ -209,12 +208,24 @@ describe('NPM Resource', () => {
 		expect(resource.cleanup).toBeDefined();
 
 		const resourcePath = await resource.getAbsoluteDirectoryPath();
-		const existsBefore = await Result.tryPromise(() => fs.stat(resourcePath));
-		expect(existsBefore.isOk()).toBe(true);
+		let existsBefore = false;
+		try {
+			await fs.stat(resourcePath);
+			existsBefore = true;
+		} catch {
+			existsBefore = false;
+		}
+		expect(existsBefore).toBe(true);
 
 		await resource.cleanup?.();
-		const existsAfter = await Result.tryPromise(() => fs.stat(resourcePath));
-		expect(existsAfter.isOk()).toBe(false);
+		let existsAfter = false;
+		try {
+			await fs.stat(resourcePath);
+			existsAfter = true;
+		} catch {
+			existsAfter = false;
+		}
+		expect(existsAfter).toBe(false);
 	});
 
 	it('uses readable fsName aliases for anonymous npm resources', async () => {

package/src/resources/impls/npm.ts

@@ -1,8 +1,6 @@
 import { promises as fs } from 'node:fs';
 import path from 'node:path';
 
-import { Result } from 'better-result';
-
 import { CommonHints } from '../../errors.ts';
 import { ResourceError, resourceNameToKey } from '../helpers.ts';
 import type { BtcaFsResource, BtcaNpmResourceArgs } from '../types.ts';
@@ -42,15 +40,20 @@ type NpmPackageVersion = {
 };
 
 const cleanupDirectory = async (pathToRemove: string) => {
-	await Result.tryPromise(() => fs.rm(pathToRemove, { recursive: true, force: true }));
+	try {
+		await fs.rm(pathToRemove, { recursive: true, force: true });
+	} catch {
+		return;
+	}
 };
 
 const directoryExists = async (directoryPath: string) => {
-	const result = await Result.tryPromise(() => fs.stat(directoryPath));
-	return result.match({
-		ok: (stat) => stat.isDirectory(),
-		err: () => false
-	});
+	try {
+		const stat = await fs.stat(directoryPath);
+		return stat.isDirectory();
+	} catch {
+		return false;
+	}
 };
 
 const encodePackagePath = (packageName: string) =>
@@ -80,64 +83,61 @@ const resolveRequestedVersion = (packument: NpmPackument, requestedVersion?: str
 };
 
 const fetchJson = async <T>(url: string, resourceName: string): Promise<T> => {
-	const response = await Result.tryPromise(() =>
-		fetch(url, {
+	let response: Response;
+	try {
+		response = await fetch(url, {
 			headers: {
 				accept: 'application/json'
 			}
-		})
-	);
-
-	if (!Result.isOk(response)) {
+		});
+	} catch (cause) {
 		throw new ResourceError({
 			message: `Failed to fetch npm metadata for "${resourceName}"`,
 			hint: CommonHints.CHECK_NETWORK,
-			cause: response.error
+			cause
 		});
 	}
 
-	if (!response.value.ok) {
+	if (!response.ok) {
 		throw new ResourceError({
-			message: `Failed to fetch npm metadata for "${resourceName}" (${response.value.status})`,
+			message: `Failed to fetch npm metadata for "${resourceName}" (${response.status})`,
 			hint:
-				response.value.status === 404
-					? 'Check that the npm package exists.'
-					: CommonHints.CHECK_NETWORK,
-			cause: new Error(`Unexpected status ${response.value.status}`)
+				response.status === 404 ? 'Check that the npm package exists.' : CommonHints.CHECK_NETWORK,
+			cause: new Error(`Unexpected status ${response.status}`)
 		});
 	}
 
-	const parsed = await Result.tryPromise(() => response.value.json() as Promise<T>);
-	if (!Result.isOk(parsed)) {
+	try {
+		return (await response.json()) as T;
+	} catch (cause) {
 		throw new ResourceError({
 			message: `Failed to parse npm metadata for "${resourceName}"`,
 			hint: 'Try again. If the issue persists, the npm registry may be returning malformed data.',
-			cause: parsed.error
+			cause
 		});
 	}
-
-	return parsed.value;
 };
 
 const fetchText = async (url: string, resourceName: string) => {
 	const fallbackContent = (reason: string) =>
 		`<!-- npm package page unavailable for "${resourceName}" (${reason}) -->`;
 
-	const response = await Result.tryPromise(() => fetch(url));
-	if (!Result.isOk(response)) {
+	let response: Response;
+	try {
+		response = await fetch(url);
+	} catch {
 		return fallbackContent('request failed');
 	}
 
-	if (!response.value.ok) {
-		return fallbackContent(`status ${response.value.status}`);
+	if (!response.ok) {
+		return fallbackContent(`status ${response.status}`);
 	}
 
-	const textResult = await Result.tryPromise(() => response.value.text());
-	if (!Result.isOk(textResult)) {
+	try {
+		return await response.text();
+	} catch {
 		return fallbackContent('response read failed');
 	}
-
-	return textResult.value;
 };
 
 const readProcessOutput = async (stream: ReadableStream<Uint8Array> | null) => {
@@ -243,18 +243,12 @@ const formatResourceOverview = (args: {
 };
 
 const readCacheMeta = async (localPath: string): Promise<NpmCacheMeta | null> => {
-	const result = await Result.gen(async function* () {
-		const content = yield* Result.await(
-			Result.tryPromise(() => Bun.file(path.join(localPath, NPM_CACHE_META_FILE)).text())
-		);
-		const parsed = yield* Result.try(() => JSON.parse(content) as NpmCacheMeta);
-		return Result.ok(parsed);
-	});
-
-	return result.match({
-		ok: (value) => value,
-		err: () => null
-	});
+	try {
+		const content = await Bun.file(path.join(localPath, NPM_CACHE_META_FILE)).text();
+		return JSON.parse(content) as NpmCacheMeta;
+	} catch {
+		return null;
+	}
 };
 
 const shouldReuseCache = async (
@@ -282,19 +276,18 @@ const installPackageFiles = async (args: {
 	const installDirectory = path.join(args.localPath, NPM_INSTALL_STAGING_DIR);
 	const packagePath = path.join(installDirectory, 'node_modules', ...args.packageName.split('/'));
 
-	const createInstallDirectory = await Result.tryPromise(() =>
-		fs.mkdir(installDirectory, { recursive: true })
-	);
-	if (!Result.isOk(createInstallDirectory)) {
+	try {
+		await fs.mkdir(installDirectory, { recursive: true });
+	} catch (cause) {
 		throw new ResourceError({
 			message: `Failed to prepare npm install workspace for "${args.packageName}"`,
 			hint: 'Check that the btca data directory is writable.',
-			cause: createInstallDirectory.error
+			cause
 		});
 	}
 
-	const writeManifest = await Result.tryPromise(() =>
-		Bun.write(
+	try {
+		await Bun.write(
 			path.join(installDirectory, 'package.json'),
 			JSON.stringify(
 				{
@@ -304,13 +297,12 @@ const installPackageFiles = async (args: {
 				null,
 				2
 			)
-		)
-	);
-	if (!Result.isOk(writeManifest)) {
+		);
+	} catch (cause) {
 		throw new ResourceError({
 			message: `Failed to prepare npm install workspace for "${args.packageName}"`,
 			hint: 'Check that the btca data directory is writable.',
-			cause: writeManifest.error
+			cause
 		});
 	}
 
@@ -329,14 +321,13 @@ const installPackageFiles = async (args: {
 			});
 		}
 
-		const copyResult = await Result.tryPromise(() =>
-			fs.cp(packagePath, args.localPath, { recursive: true, force: true })
-		);
-		if (!Result.isOk(copyResult)) {
+		try {
+			await fs.cp(packagePath, args.localPath, { recursive: true, force: true });
+		} catch (cause) {
 			throw new ResourceError({
 				message: `Failed to copy installed npm package files for "${args.packageName}"`,
 				hint: 'Check filesystem permissions and available disk space.',
-				cause: copyResult.error
+				cause
 			});
 		}
 	} finally {
@@ -431,27 +422,27 @@ const ensureNpmResource = async (config: BtcaNpmResourceArgs): Promise<string> =
 		: config.resourcesDirectoryPath;
 	const localPath = path.join(basePath, resourceKey);
 
-	const mkdirResult = await Result.tryPromise({
-		try: () => fs.mkdir(basePath, { recursive: true }),
-		catch: (cause) =>
-			new ResourceError({
-				message: 'Failed to create resources directory',
-				hint: 'Check that you have write permissions to the btca data directory.',
-				cause
-			})
-	});
-	if (!Result.isOk(mkdirResult)) throw mkdirResult.error;
+	try {
+		await fs.mkdir(basePath, { recursive: true });
+	} catch (cause) {
+		throw new ResourceError({
+			message: 'Failed to create resources directory',
+			hint: 'Check that you have write permissions to the btca data directory.',
+			cause
+		});
+	}
 
 	const canReuse = await shouldReuseCache(config, localPath);
 	if (canReuse) return localPath;
 
 	await cleanupDirectory(localPath);
-	const createResult = await Result.tryPromise(() => fs.mkdir(localPath, { recursive: true }));
-	if (!Result.isOk(createResult)) {
+	try {
+		await fs.mkdir(localPath, { recursive: true });
+	} catch (cause) {
 		throw new ResourceError({
 			message: `Failed to prepare npm resource directory for "${config.name}"`,
 			hint: 'Check that the btca data directory is writable.',
-			cause: createResult.error
+			cause
 		});
 	}
 

package/src/resources/index.ts

@@ -1,5 +1,10 @@
 export { ResourceError } from './helpers.ts';
-export { Resources } from './service.ts';
+export {
+	createResourcesService,
+	createAnonymousResource,
+	resolveResourceDefinition
+} from './service.ts';
+export type { ResourcesService } from './service.ts';
 export {
 	GitResourceSchema,
 	LocalResourceSchema,

package/src/resources/schema.ts

@@ -1,4 +1,3 @@
-import { Result } from 'better-result';
 import { z } from 'zod';
 
 import { LIMITS } from '../validation/index.ts';
@@ -21,11 +20,13 @@ const BRANCH_NAME_REGEX = /^[a-zA-Z0-9/_.-]+$/;
 const NPM_PACKAGE_SEGMENT_REGEX = /^[a-z0-9][a-z0-9._-]*$/;
 const NPM_VERSION_OR_TAG_REGEX = /^[^\s/]+$/;
 
-const parseUrl = (value: string) =>
-	Result.try(() => new URL(value)).match({
-		ok: (url) => url,
-		err: () => null
-	});
+const parseUrl = (value: string) => {
+	try {
+		return new URL(value);
+	} catch {
+		return null;
+	}
+};
 
 // ─────────────────────────────────────────────────────────────────────────────
 // Field Schemas

package/src/resources/service.test.ts

@@ -1,6 +1,10 @@
 import { describe, expect, it } from 'bun:test';
 
-import { Resources, createAnonymousDirectoryKey } from './service.ts';
+import {
+	createAnonymousDirectoryKey,
+	createAnonymousResource,
+	resolveResourceDefinition
+} from './service.ts';
 import { resourceNameToKey } from './helpers.ts';
 import { type ResourceDefinition } from './schema.ts';
 
@@ -16,13 +20,13 @@ describe('Resources.resolveResourceDefinition', () => {
 	const getResource = (name: string) => (name === 'svelte' ? configuredResource : undefined);
 
 	it('resolves configured resources by name first', () => {
-		const definition = Resources.resolveResourceDefinition('svelte', getResource);
+		const definition = resolveResourceDefinition('svelte', getResource);
 		expect(definition.type).toBe('git');
 		expect(definition.name).toBe('svelte');
 	});
 
 	it('creates anonymous git resources from valid URLs', () => {
-		const definition = Resources.resolveResourceDefinition(
+		const definition = resolveResourceDefinition(
 			'https://github.com/sveltejs/svelte.dev/tree/main/packages',
 			() => undefined
 		);
@@ -35,10 +39,7 @@ describe('Resources.resolveResourceDefinition', () => {
 	});
 
 	it('creates anonymous npm resources from npm references', () => {
-		const definition = Resources.resolveResourceDefinition(
-			'npm:@types/node@22.10.1',
-			() => undefined
-		);
+		const definition = resolveResourceDefinition('npm:@types/node@22.10.1', () => undefined);
 		expect(definition.type).toBe('npm');
 		if (definition.type === 'npm') {
 			expect(definition.package).toBe('@types/node');
@@ -48,7 +49,7 @@ describe('Resources.resolveResourceDefinition', () => {
 	});
 
 	it('creates anonymous npm resources from npm package URLs', () => {
-		const definition = Resources.resolveResourceDefinition(
+		const definition = resolveResourceDefinition(
 			'https://www.npmjs.com/package/react/v/19.0.0',
 			() => undefined
 		);
@@ -60,8 +61,8 @@ describe('Resources.resolveResourceDefinition', () => {
 	});
 
 	it('reuses the same cache key for repeated normalized URLs', () => {
-		const first = Resources.createAnonymousResource('https://github.com/sveltejs/svelte.dev');
-		const second = Resources.createAnonymousResource(
+		const first = createAnonymousResource('https://github.com/sveltejs/svelte.dev');
+		const second = createAnonymousResource(
 			'https://github.com/sveltejs/svelte.dev/blob/main/packages'
 		);
 		expect(first).not.toBeNull();
@@ -72,8 +73,8 @@ describe('Resources.resolveResourceDefinition', () => {
 	});
 
 	it('uses short deterministic keys for anonymous repository paths', () => {
-		const main = Resources.createAnonymousResource('https://github.com/sveltejs/svelte.dev');
-		const withPath = Resources.createAnonymousResource(
+		const main = createAnonymousResource('https://github.com/sveltejs/svelte.dev');
+		const withPath = createAnonymousResource(
 			'https://github.com/sveltejs/svelte.dev/tree/main/packages'
 		);
 		expect(main).not.toBeNull();