Tests passing

Author: 404Wolf

src/consts.ts

@@ -51,3 +51,5 @@ export const VAL_TOWN_PROJECT_URL_REGEX =
 
 export type ProjectItemType = typeof ProjectItems[number];
 export type ProjectFileType = Exclude<ProjectItemType, "directory">;
+
+export const RECENT_VERSION_COUNT = 5;

src/vt/lib/clone.ts

@@ -35,13 +35,12 @@ export function clone({
         version,
         branch_id: branchId,
         path: "",
+        recursive: true,
       });
 
       await Promise.all(projectItems
+        .filter(file => !shouldIgnore(file.path, gitignoreRules))
         .map(async (file) => {
-          // Skip ignored files
-          if (shouldIgnore(file.path, gitignoreRules)) return;
-
           if (file.type === "directory") {
             // Create directories, even if they would otherwise get created during
             // the createFile call later, so that we get empty directories

src/vt/lib/paths.ts

@@ -1,4 +1,8 @@
-import { DEFAULT_VAL_TYPE, type ProjectItemType } from "~/consts.ts";
+import {
+  DEFAULT_VAL_TYPE,
+  type ProjectItemType,
+  RECENT_VERSION_COUNT,
+} from "~/consts.ts";
 import { filePathToFile } from "~/sdk.ts";
 import { compile as compileGitignore } from "gitignore-parser";
 
@@ -27,67 +31,41 @@ async function getProjectItemType(
   version: number,
   filePath: string,
 ): Promise<ProjectItemType> {
-  try {
-    // Try up to 5 previous versions to determine the type
-    for (let i = 0; i < 5; i++) {
-      try {
-        // Try to get the file at the current version min, ensuring version
-        // doesn't go below 1
-        const versionToCheck = Math.max(1, version - i);
-        const result = await filePathToFile(
-          projectId,
-          branchId,
-          versionToCheck,
-          filePath,
-        )
-          .then((resp) => resp.type);
-        return result;
-      } catch (e) {
-        // If not found and we haven't tried all versions yet, continue to the
-        // next version
-        if (e instanceof Deno.errors.NotFound && i < 4) {
-          continue;
-        } else if (!(e instanceof Deno.errors.NotFound) || i >= 4) {
-          // If it's not a NotFound error or we've tried all versions, handle
-          // it in the outer catch
-          throw e;
-        }
-      }
+  for (let i = version; i > version - RECENT_VERSION_COUNT; i--) {
+    try {
+      return await filePathToFile(projectId, branchId, version, filePath)
+        .then((resp) => resp.type);
+    } catch (e) {
+      if (e instanceof Deno.errors.NotFound) {
+        continue;
+      } else throw e;
     }
+  }
 
-    // If we get here, we couldn't find the file in any of the 5 versions
-    throw new Deno.errors.NotFound();
-  } catch (e) {
-    // Otherwise, if it ends in .ts, .js, .tsx, or .jsx, it is a val
-    if (e instanceof Deno.errors.NotFound) {
-      if (/\.(ts|tsx|js|jsx)$/.test(filePath)) {
-        const isCron = filePath.includes("cron");
-        const isHttp = filePath.includes("http");
-        const isEmail = filePath.includes("email");
-
-        // If it's ambiguous then it is a script val by default
-        if ([isCron, isHttp, isEmail].filter(Boolean).length > 1) {
-          return DEFAULT_VAL_TYPE;
-        }
+  // Otherwise, if it ends in .ts, .js, .tsx, or .jsx, it is a val
+  if (/\.(ts|tsx|js|jsx)$/.test(filePath)) {
+    const isCron = filePath.includes("cron");
+    const isHttp = filePath.includes("http");
+    const isEmail = filePath.includes("email");
 
-        // But otherwise look at the file name and try to figure out what type
-        // of val it is based on whether the file name contains a pattern like
-        // "cron," etc
-        if (isCron) return "interval";
-        if (isHttp) return "http";
-        if (isEmail) return "email";
+    // If it's ambiguous then it is a script val by default
+    if ([isCron, isHttp, isEmail].filter(Boolean).length > 1) {
+      return DEFAULT_VAL_TYPE;
+    }
 
-        // If we can't figure it out, default to script
-        return DEFAULT_VAL_TYPE;
-      }
+    // But otherwise look at the file name and try to figure out what type
+    // of val it is based on whether the file name contains a pattern like
+    // "cron," etc
+    if (isCron) return "interval";
+    if (isHttp) return "http";
+    if (isEmail) return "email";
 
-      // Otherwise, it's just a plain old file val
-      return "file";
-    } else {
-      // Re-throw any other errors
-      throw e;
-    }
+    // If we can't figure it out, default to script
+    return DEFAULT_VAL_TYPE;
   }
+
+  // Otherwise, it's just a plain old file val
+  return "file";
 }
 
 /**

src/vt/lib/push.ts

@@ -45,28 +45,31 @@ export async function push({
   });
 
   // Upload files that were modified locally
-  const modifiedPromises = statusResult.modified
-    .filter((file) => file.type !== "directory")
-    .map(async (file) => {
-      await sdk.projects.files.update(
-        projectId,
-        {
-          path: file.path,
-          branch_id: branchId,
-          content: await Deno.readTextFile(path.join(targetDir, file.path)),
-          name: path.basename(file.path),
-          type: file.type as Exclude<ProjectItemType, "directory">,
-        },
-      );
-    });
+  await Promise.all(
+    statusResult.modified
+      .filter((file) => file.type !== "directory")
+      .map(async (file) => {
+        await sdk.projects.files.update(
+          projectId,
+          {
+            path: file.path,
+            branch_id: branchId,
+            content: await Deno.readTextFile(path.join(targetDir, file.path)),
+            name: path.basename(file.path),
+            type: file.type as Exclude<ProjectItemType, "directory">,
+          },
+        );
+      }),
+  );
 
   // Delete files that exist on the server but not locally
-  const deletedPromises = statusResult.deleted.map(async (file) => {
+  await Promise.all(statusResult.deleted.map(async (file) => {
     await sdk.projects.files.delete(projectId, {
       path: file.path,
       branch_id: branchId,
+      recursive: true,
     });
-  });
+  }));
 
   // First ensure all directories exist
   for (const file of statusResult.created) {
@@ -98,12 +101,6 @@ export async function push({
     }
   }
 
-  // Wait for all operations to complete
-  await Promise.all([
-    ...modifiedPromises,
-    ...deletedPromises,
-  ]);
-
   return statusResult;
 }
 
@@ -116,9 +113,6 @@ async function ensureValtownDir(
   // Note that we cannot use path logic here because it must specific to val town
   const dirPath = isDirectory ? filePath : path.dirname(filePath);
 
-  // If path is "." (current directory) or empty, no directories need to be created
-  if (dirPath === "." || dirPath === "") return;
-
   // Split the path into segments
   const segments = dirPath.split("/");
   let currentPath = "";