Merge branch 'main' into config-cache

Author: 404Wolf

install.ts

@@ -44,7 +44,7 @@ export const checkoutCmd = new Command()
     ) => {
       doWithSpinner("Checking out branch...", async (spinner) => {
         const vt = VTClient.from(await findVtRoot(Deno.cwd()));
-        const state = await vt.getMeta().loadState();
+        const config = await vt.getMeta().loadState();
 
         const statusResult = await vt.status();
 
@@ -55,7 +55,7 @@ export const checkoutCmd = new Command()
               await vt.isDirty({
                 statusResult: await vt.status({
                   branchId: (await branchIdToBranch(
-                    state.project.id,
+                    config.project.id,
                     existingBranchName,
                   )).id,
                 }),
@@ -71,7 +71,7 @@ export const checkoutCmd = new Command()
           try {
             checkoutResult = await vt
               .checkout(branch, {
-                forkedFrom: state.branch.id,
+                forkedFrom: config.branch.id,
                 statusResult,
               });
 

src/cmd/lib/checkout.ts

@@ -1,7 +1,5 @@
 import { Command } from "@cliffy/command";
 import { basename, join } from "@std/path";
-import { checkDirectory } from "~/utils.ts";
-import { DEFAULT_IGNORE_PATTERNS } from "~/consts.ts";
 import VTClient from "~/vt/vt/VTClient.ts";
 import { user } from "~/sdk.ts";
 import { APIError } from "@valtown/sdk";
@@ -57,7 +55,10 @@ vt checkout main`,
     targetDir?: string,
   ) => {
     doWithSpinner("Creating project...", async (spinner) => {
-      let rootPath = targetDir || Deno.cwd();
+      let rootPath: string;
+      if (!targetDir) {
+        rootPath = join(Deno.cwd(), projectName);
+      } else rootPath = targetDir;
 
       // Check for mutually exclusive privacy flags
       const privacyFlags =
@@ -81,14 +82,6 @@ vt checkout main`,
         );
         await vt.addEditorFiles();
 
-        // If no target directory specified, use project name
-        if (targetDir === undefined) rootPath = join(rootPath, projectName);
-
-        // Make sure directory is safe to create project in
-        await checkDirectory(rootPath, {
-          gitignoreRules: DEFAULT_IGNORE_PATTERNS,
-        });
-
         spinner.succeed(
           `Created ${privacy} project ${projectName} in ./${
             basename(rootPath)

src/cmd/lib/create.ts

@@ -50,10 +50,12 @@ export const ProjectItems = [
   "directory",
 ] as const;
 
+export const JSON_INDENT_SPACES = 4;
+
 export const VAL_TOWN_PROJECT_URL_REGEX =
   /^http[s]?:\/\/www\.val\.town\/x\/([^\/]+)\/([^\/]+)$/;
 
 export type ProjectItemType = typeof ProjectItems[number];
 export type ProjectFileType = Exclude<ProjectItemType, "directory">;
 
-export const JSON_INDENT_SPACES = 4;
+export const RECENT_VERSION_COUNT = 5;

src/consts.ts

@@ -64,43 +64,49 @@ async function filePathToFile(
  * @param {string} projectId The ID of the project
  * @param {Object} params The parameters for listing project items
  * @param {string} params.path The root path to start listing from
- * @param {string} params.branch_id The ID of the project branch to reference
- * @param {number} params.version The version of the project
+ * @param {string} [params.branch_id] The ID of the project branch to reference. Defaults to main.
+ * @param {number} [params.version] - The version of the project. Defaults to latest.
  * @param {Object} [params.options] Additional options for filtering
  * @param {boolean} [params.options.recursive=true] Whether to recursively list files in subdirectories
  * @returns {Promise<Set<string>>} Promise resolving to a Set of file paths
  * @throws {Error} if the API request fails
  */
 export async function listProjectItems(
   projectId: string,
-  { path, branch_id, version, recursive }: {
+  {
+    path,
+    branch_id,
+    version,
+    recursive,
+  }: {
     path: string;
-    branch_id: string;
-    version: number;
+    branch_id?: string;
+    version?: number;
     recursive?: boolean;
   },
 ): Promise<ValTown.Projects.FileRetrieveResponse.Data[]> {
   const files: ValTown.Projects.FileRetrieveResponse.Data[] = [];
   let cursor = 0;
-  const batch = 100;
+  const batchSize = 100; // Single, reasonable batch size
 
   while (true) {
     const resp = await sdk.projects.files.retrieve(projectId, {
       path,
       offset: cursor,
-      limit: batch,
+      limit: batchSize,
       branch_id,
       version,
-      recursive: recursive ?? true,
+      recursive,
     });
 
-    resp.data.forEach((file) => files.push(file));
+    // Add the files to our result array
+    files.push(...resp.data);
 
-    // If no more results or we've reached the end, break
-    if (resp.data.length === 0) break;
+    // If we got fewer items than the batch size, we've reached the end
+    if (!resp.links.next) break;
 
     // Move to next batch
-    cursor += batch;
+    cursor += batchSize;
   }
 
   return files;

src/sdk.ts

@@ -113,6 +113,7 @@ export function checkout(
           path: "",
           branch_id: fromBranch.id,
           version: fromBranch.version,
+          recursive: true,
         }).then((resp) => resp.map((file) => file.path)),
       );
 
@@ -122,6 +123,7 @@ export function checkout(
           path: "",
           branch_id: checkoutBranchId,
           version: checkoutVersion,
+          recursive: true,
         }).then((resp) => resp.map((file) => file.path)),
       );
 
@@ -141,7 +143,7 @@ export function checkout(
         const relativePath = relative(args.targetDir, entry.path);
 
         // Skip files that match gitignore rules
-        if (await shouldIgnore(relativePath, args.gitignoreRules)) continue;
+        if (shouldIgnore(relativePath, args.gitignoreRules)) continue;
 
         // Skip root directory
         if (relativePath === "" || entry.path === args.targetDir) continue;

src/vt/lib/checkout.ts

@@ -35,29 +35,30 @@ export function clone({
         version,
         branch_id: branchId,
         path: "",
+        recursive: true,
       });
 
-      await Promise.all(projectItems
-        .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
-            await ensureDir(path.join(tmpDir, file.path));
-          } else {
-            // Start a create file task in the background
-            const fullPath = path.join(tmpDir, file.path);
-            await createFile(
-              fullPath,
-              projectId,
-              branchId,
-              version,
-              file,
-            );
-          }
-        }));
+      await Promise.all(
+        projectItems
+          .filter((file) => !shouldIgnore(file.path, gitignoreRules))
+          .map(async (file) => {
+            if (file.type === "directory") {
+              // Create directories, even if they would otherwise get created during
+              // the createFile call later, so that we get empty directories
+              await ensureDir(path.join(tmpDir, file.path));
+            } else {
+              // Start a create file task in the background
+              const fullPath = path.join(tmpDir, file.path);
+              await createFile(
+                fullPath,
+                projectId,
+                branchId,
+                version,
+                file,
+              );
+            }
+          }),
+      );
     },
     targetDir,
     "vt_clone_",

src/vt/lib/clone.ts

@@ -1,4 +1,8 @@
-import { DEFAULT_VAL_TYPE, type ProjectItemType } from "~/consts.ts";
+import {
+  DEFAULT_VAL_TYPE,
+  RECENT_VERSION_COUNT,
+  type ProjectItemType
+} from "~/consts.ts";
 import { filePathToFile } from "~/sdk.ts";
 import { compile as compileGitignore } from "gitignore-parser";
 
@@ -27,42 +31,41 @@ async function getProjectItemType(
   version: number,
   filePath: string,
 ): Promise<ProjectItemType> {
-  try {
-    // If a file already exists in the project at the given path, then the type
-    // is whatever it already is on the website.
-    return await filePathToFile(projectId, branchId, version, filePath)
-      .then((resp) => resp.type);
-  } 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");
+  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 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/paths.ts

@@ -64,6 +64,7 @@ export function pull({
           path: "",
           branch_id: branchId,
           version,
+          recursive: true,
         }).then((resp) => resp.map((file) => file.path)),
       );