btca-server 2.0.2 → 2.0.3

package/src/resources/service.ts

@@ -41,13 +41,13 @@ export type ResourcesService = {
 		options?: {
 			quiet?: boolean;
 		}
-	) => Promise<BtcaFsResource>;
-	loadEffect: (
+	) => Effect.Effect<BtcaFsResource, ResourceError, never>;
+	loadPromise: (
 		name: string,
 		options?: {
 			quiet?: boolean;
 		}
-	) => Effect.Effect<BtcaFsResource, ResourceError>;
+	) => Promise<BtcaFsResource>;
 };
 
 const normalizeSearchPaths = (definition: GitResource): string[] => {
@@ -154,55 +154,56 @@ export const resolveResourceDefinition = (
 };
 
 export const createResourcesService = (config: ConfigServiceShape): ResourcesService => {
-	const loadEffect: ResourcesService['loadEffect'] = (name, options) =>
-		Effect.gen(function* () {
-			const quiet = options?.quiet ?? false;
-			const definition = yield* Effect.try({
-				try: () => resolveResourceDefinition(name, config.getResource),
-				catch: (cause) =>
-					cause instanceof ResourceError
-						? cause
-						: new ResourceError({
-								message: `Failed to resolve resource "${name}"`,
-								hint: `${CommonHints.LIST_RESOURCES} ${CommonHints.ADD_RESOURCE}`,
-								cause
-							})
-			});
-
-			if (isGitResource(definition)) {
-				return yield* Effect.tryPromise({
-					try: () =>
-						loadGitResource(definitionToGitArgs(definition, config.resourcesDirectory, quiet)),
-					catch: (cause) =>
-						cause instanceof ResourceError
-							? cause
-							: new ResourceError({
-									message: `Failed to load git resource "${name}"`,
-									hint: CommonHints.CLEAR_CACHE,
-									cause
-								})
+	const loadPromise: ResourcesService['loadPromise'] = async (name, options) => {
+		const quiet = options?.quiet ?? false;
+		const definition = resolveResourceDefinition(name, config.getResource);
+
+		if (isGitResource(definition)) {
+			try {
+				return await loadGitResource(
+					definitionToGitArgs(definition, config.resourcesDirectory, quiet)
+				);
+			} catch (cause) {
+				if (cause instanceof ResourceError) throw cause;
+				throw new ResourceError({
+					message: `Failed to load git resource "${name}"`,
+					hint: CommonHints.CLEAR_CACHE,
+					cause
 				});
 			}
+		}
 
-			if (isNpmResource(definition)) {
-				return yield* Effect.tryPromise({
-					try: () => loadNpmResource(definitionToNpmArgs(definition, config.resourcesDirectory)),
-					catch: (cause) =>
-						cause instanceof ResourceError
-							? cause
-							: new ResourceError({
-									message: `Failed to load npm resource "${name}"`,
-									hint: CommonHints.CLEAR_CACHE,
-									cause
-								})
+		if (isNpmResource(definition)) {
+			try {
+				return await loadNpmResource(definitionToNpmArgs(definition, config.resourcesDirectory));
+			} catch (cause) {
+				if (cause instanceof ResourceError) throw cause;
+				throw new ResourceError({
+					message: `Failed to load npm resource "${name}"`,
+					hint: CommonHints.CLEAR_CACHE,
+					cause
 				});
 			}
+		}
+
+		return loadLocalResource(definitionToLocalArgs(definition));
+	};
 
-			return loadLocalResource(definitionToLocalArgs(definition));
+	const load: ResourcesService['load'] = (name, options) =>
+		Effect.tryPromise({
+			try: () => loadPromise(name, options),
+			catch: (cause) =>
+				cause instanceof ResourceError
+					? cause
+					: new ResourceError({
+							message: `Failed to resolve resource "${name}"`,
+							hint: `${CommonHints.LIST_RESOURCES} ${CommonHints.ADD_RESOURCE}`,
+							cause
+						})
 		});
 
 	return {
-		load: (name, options) => Effect.runPromise(loadEffect(name, options)),
-		loadEffect
+		load,
+		loadPromise
 	};
 };

package/src/vfs/virtual-fs.ts

@@ -281,3 +281,76 @@ export const importDirectoryIntoVirtualFs = async (args: {
 	await mkdirVirtualFs(dest, { recursive: true }, vfsId);
 	await walk(base);
 };
+
+export const importPathsIntoVirtualFs = async (args: {
+	sourcePath: string;
+	destinationPath: string;
+	relativePaths: readonly string[];
+	vfsId?: string;
+}) => {
+	const base = path.resolve(args.sourcePath);
+	const dest = normalizeVfsPath(args.destinationPath);
+	const vfsId = args.vfsId;
+	const uniquePaths = Array.from(
+		new Set(
+			args.relativePaths
+				.map((relativePath) => relativePath.trim())
+				.filter((relativePath) => relativePath.length > 0 && relativePath !== '.')
+		)
+	).sort((left, right) => left.localeCompare(right));
+
+	await mkdirVirtualFs(dest, { recursive: true }, vfsId);
+
+	for (const relativePath of uniquePaths) {
+		const sourcePath = path.join(base, relativePath);
+		const destinationPath = normalizeVfsPath(
+			posix.join(dest, relativePath.split(path.sep).join('/'))
+		);
+
+		let stat: Awaited<ReturnType<typeof fs.lstat>> | null = null;
+		try {
+			stat = await fs.lstat(sourcePath);
+		} catch {
+			stat = null;
+		}
+		if (!stat) continue;
+
+		await mkdirVirtualFs(posix.dirname(destinationPath), { recursive: true }, vfsId);
+
+		if (stat.isDirectory()) {
+			await mkdirVirtualFs(destinationPath, { recursive: true }, vfsId);
+			continue;
+		}
+
+		if (stat.isSymbolicLink()) {
+			let target: string | null = null;
+			try {
+				target = await fs.readlink(sourcePath);
+			} catch {
+				target = null;
+			}
+			if (!target) continue;
+			try {
+				await symlinkVirtualFs(target, destinationPath, vfsId);
+			} catch {
+				// Ignore invalid symlink entries while importing.
+			}
+			continue;
+		}
+
+		if (!stat.isFile()) continue;
+
+		let buffer: Buffer | null = null;
+		try {
+			buffer = await fs.readFile(sourcePath);
+		} catch {
+			buffer = null;
+		}
+		if (!buffer) continue;
+		try {
+			await writeVirtualFsFile(destinationPath, buffer, vfsId);
+		} catch {
+			// Ignore individual file write errors while importing.
+		}
+	}
+};