fix: apply manifest should appload the whole directory recursively

Author: RonenMars

src/controllers/utilities/resources.util.ts

@@ -24,15 +24,22 @@ export const getLocalResources = async (
 		const fileName = path.basename(resourcesPath);
 		try {
 			const fileBuffer = fs.readFileSync(resourcesPath);
-			const mappedResources = { [fileName]: fileBuffer };
+			const mappedResources = { [fileName]: new Uint8Array(fileBuffer) };
 			return { data: mappedResources };
 		} catch (error) {
 			return { error: error as Error };
 		}
 	}
-	const mappedResources = stats.isFile()
-		? await mapFilesToContentInBytes(resourcesPath, [resourcesPath])
-		: await mapFilesToContentInBytes(resourcesPath, await readDirectoryRecursive(resourcesPath));
 
-	return { data: mappedResources };
+	try {
+		const allFiles = await readDirectoryRecursive(resourcesPath);
+		const mappedBuffers = await mapFilesToContentInBytes(resourcesPath, allFiles);
+		const mappedResources: Record<string, Uint8Array> = {};
+		for (const [key, buffer] of Object.entries(mappedBuffers)) {
+			mappedResources[key] = new Uint8Array(buffer);
+		}
+		return { data: mappedResources };
+	} catch (error) {
+		return { error: error as Error };
+	}
 };

src/utilities/fileSystem.utils.ts

@@ -99,28 +99,30 @@ export const readDirectoryRecursive = async (directoryPath: string): Promise<str
 	let files: string[] = [];
 	const isWin = process.platform === "win32";
 
-	const readDirSync = (dirPath: string) => {
-		fs.readdirSync(dirPath).forEach(async (file) => {
+	const readDirRecursive = async (dirPath: string): Promise<void> => {
+		const entries = fs.readdirSync(dirPath);
+
+		for (const file of entries) {
 			const fullPath = path.join(dirPath, file);
 
 			if (isWin && isWinHiddenPath(fullPath)) {
-				return;
+				continue;
 			}
 
 			if (!isWin && isUnixHiddenPath(fullPath)) {
-				return;
+				continue;
 			}
 
 			const stats = fs.statSync(fullPath);
 			if (stats.isDirectory()) {
-				files = files.concat(await readDirectoryRecursive(fullPath));
+				await readDirRecursive(fullPath);
 			} else if (stats.isFile()) {
 				files.push(fullPath);
 			}
-		});
+		}
 	};
 
-	readDirSync(directoryPath);
+	await readDirRecursive(directoryPath);
 	return files;
 };
 

src/vscommands/applyManifest.vscommands.ts

@@ -50,7 +50,7 @@ export const applyManifest = async () => {
 		return;
 	}
 
-	const { error: createError } = await ProjectsService.create({
+	const { data: projectId, error: createError } = await ProjectsService.create({
 		name: projectName,
 		organizationId,
 	});
@@ -78,34 +78,13 @@ export const applyManifest = async () => {
 		}
 		const manifestDirectory = getDirectoryOfFile(filePath);
 
-		if (!manifestResponse?.projectIds.length) {
-			LoggerService.error(
-				namespaces.applyManifest,
-				translate().t("errors.applyManifestNoProjectsLog", {
-					request: "applyManifest",
-				})
-			);
-			return;
-		}
-
-		const { logs, projectIds } = manifestResponse!;
+		const { logs } = manifestResponse!;
 		const currentProjectPaths = (await commands.executeCommand(
 			vsCommands.getContext,
 			"projectsPaths"
 		)) as unknown as string;
 
 		let vscodeProjectsPaths = JSON.parse(currentProjectPaths);
-		if (!projectIds.length) {
-			commands.executeCommand(vsCommands.showErrorMessage, translate().t("manifest.ProjectCreationFailed"));
-			LoggerService.error(
-				namespaces.applyManifest,
-				translate().t("manifest.ProjectCreationFailedLog", {
-					request: "applyManifest",
-					error: (createError as Error).message,
-				})
-			);
-			return;
-		}
 
 		if (Object.keys(vscodeProjectsPaths || {}).length) {
 			let projectLocallyExists;
@@ -122,23 +101,22 @@ export const applyManifest = async () => {
 					vsCommands.showErrorMessage,
 					namespaces.applyManifest,
 					translate().t("projects.projectLocallyExistsFilesNotUpdated", {
-						projectId: projectIds[0],
+						projectId,
 						directory: manifestDirectory,
 					})
 				);
 
 				LoggerService.error(
 					namespaces.applyManifest,
 					translate().t("projects.projectLocallyExistsFilesNotUpdatedLog", {
-						projectId: projectIds[0],
+						projectId,
 						directory: manifestDirectory,
 					})
 				);
 				return;
 			}
 		}
-		const projectId = projectIds[0];
-		vscodeProjectsPaths[projectId] = manifestDirectory;
+		vscodeProjectsPaths[projectId!] = manifestDirectory;
 		await commands.executeCommand(vsCommands.setContext, "projectsPaths", JSON.stringify(vscodeProjectsPaths));
 
 		const organizationName =
@@ -149,7 +127,7 @@ export const applyManifest = async () => {
 		commands.executeCommand(vsCommands.showInfoMessage, translate().t("manifest.appliedSuccessfully"));
 		setTimeout(() => commands.executeCommand(vsCommands.refreshSidebar), 2500);
 
-		const { data: resources, error: resourcesError } = await getLocalResources(manifestDirectory, projectId);
+		const { data: resources, error: resourcesError } = await getLocalResources(manifestDirectory, projectId!);
 
 		if (resourcesError || !resources) {
 			LoggerService.error(
@@ -162,7 +140,7 @@ export const applyManifest = async () => {
 		const filteredResources = { ...resources };
 		delete filteredResources["autokitteh.yaml"];
 
-		const { error: setResourcesError } = await ProjectsService.setResources(projectId, filteredResources);
+		const { error: setResourcesError } = await ProjectsService.setResources(projectId!, filteredResources);
 
 		if (setResourcesError) {
 			LoggerService.error(