Make interface custom and typesafe

Author: tmcw

src/cmd/upgrade.ts

@@ -1,13 +1,9 @@
 import { UpgradeCommand } from "@cliffy/command/upgrade";
 import { JsrProvider } from "@cliffy/command/upgrade/provider/jsr";
-import {
-  JSR_ENTRY_NAME,
-  SAW_AS_LATEST_VERSION,
-  VT_MINIMUM_FLAGS,
-} from "~/consts.ts";
+import { JSR_ENTRY_NAME, VT_MINIMUM_FLAGS } from "~/consts.ts";
 import manifest from "../../deno.json" with { type: "json" };
 import { colors } from "@cliffy/ansi/colors";
-import { vtState } from "~/vt/VTState.ts";
+import { vtCheckCache } from "~/vt/VTCheckCache.ts";
 
 const provider = new JsrProvider({ package: JSR_ENTRY_NAME });
 
@@ -16,17 +12,20 @@ export async function registerOutdatedWarning() {
   const list = await provider.getVersions(JSR_ENTRY_NAME);
   const currentVersion = manifest.version;
   if (list.latest !== currentVersion) {
-    const lastSawAsLatestVersion = await vtState.getItem(SAW_AS_LATEST_VERSION);
+    const lastSawAsLatestVersion = await vtCheckCache
+      .getLastSawAsLatestVersion();
     if (lastSawAsLatestVersion !== list.latest) {
       addEventListener("unload", async () => {
         // The last thing logged
         if (Deno.args.includes("upgrade")) return; // Don't show when they are upgrading
 
-        await vtState.setItem(SAW_AS_LATEST_VERSION, currentVersion);
+        await vtCheckCache.setLastSawAsLatestVersion(currentVersion);
         console.log(
-          `A new version of vt is available: ${colors.bold(
-            list.latest,
-          )}! Run \`${colors.bold("vt upgrade")}\` to update.`,
+          `A new version of vt is available: ${
+            colors.bold(
+              list.latest,
+            )
+          }! Run \`${colors.bold("vt upgrade")}\` to update.`,
         );
       });
     }

src/consts.ts

@@ -21,7 +21,7 @@ export const META_IGNORE_FILE_NAME = ".vtignore";
 export const GLOBAL_VT_CONFIG_PATH = join(xdg.config(), PROGRAM_NAME);
 export const GLOBAL_VT_META_FILE_PATH = join(
   GLOBAL_VT_CONFIG_PATH,
-  "state.json",
+  "upgrade-status.json",
 );
 
 export const DEFAULT_WRAP_WIDTH = 80;

src/vt/VTCheckCache.ts

@@ -0,0 +1,52 @@
+import type z from "zod";
+import {
+  AUTH_CACHE_LOCALSTORE_ENTRY,
+  GLOBAL_VT_META_FILE_PATH,
+  SAW_AS_LATEST_VERSION,
+} from "../consts.ts";
+import { VTCheckCacheFile } from "~/vt/vt/schemas.ts";
+
+/**
+ * Cheap singleton that takes the place of localStorage but writes to a
+ * file within the global configuration directory.
+ *
+ * Used for caching the results of authentication and upgrade checks.
+ */
+class VTCheckCache {
+  async #read() {
+    try {
+      const text = await Deno.readTextFile(GLOBAL_VT_META_FILE_PATH);
+      const json = JSON.parse(text);
+      return VTCheckCacheFile.parse(json);
+    } catch {
+      return {};
+    }
+  }
+  async getAuthChecked() {
+    return (await this.#read())[AUTH_CACHE_LOCALSTORE_ENTRY];
+  }
+  async getLastSawAsLatestVersion() {
+    return (await this.#read())[SAW_AS_LATEST_VERSION];
+  }
+  async setAuthCheckedToNow() {
+    return await this.setItem(
+      AUTH_CACHE_LOCALSTORE_ENTRY,
+      new Date().toISOString(),
+    );
+  }
+  async setLastSawAsLatestVersion(version: string) {
+    return await this.setItem(SAW_AS_LATEST_VERSION, version);
+  }
+  async setItem(key: keyof z.infer<typeof VTCheckCacheFile>, value: string) {
+    const before = await this.#read();
+    await Deno.writeTextFile(
+      GLOBAL_VT_META_FILE_PATH,
+      JSON.stringify({
+        ...before,
+        [key]: value,
+      }),
+    );
+  }
+}
+
+export const vtCheckCache = new VTCheckCache();

src/vt/VTState.ts

@@ -1,9 +1,11 @@
 import { join } from "@std/path";
 import { z } from "zod";
 import {
+  AUTH_CACHE_LOCALSTORE_ENTRY,
   DEFAULT_EDITOR_TEMPLATE,
   GLOBAL_VT_CONFIG_PATH,
   META_IGNORE_FILE_NAME,
+  SAW_AS_LATEST_VERSION,
 } from "~/consts.ts";
 
 /**
@@ -12,57 +14,68 @@ import {
  * Contains required metadata for operations that require context about the val
  * town directory you are in, like the Val that it represents.
  */
-export const VTStateSchema = z.object({
-  project: z.object({
-    id: z.string().uuid(),
-  }).optional(),
-  val: z.object({
-    id: z.string().uuid(),
-    // Project -> Val migration: This lets old meta.jsons that have a project.id
-    // still parse, and we transform them below. That means this ID is always
-    // populated.
-  }).catch({ id: "" }),
-  branch: z.object({
-    id: z.string().uuid(),
-    version: z.number().gte(0),
-  }),
-  lastRun: z.object({
-    pid: z.number().gte(0),
-    time: z.string().refine((val) => !isNaN(Date.parse(val)), {}),
-  }),
-}).transform((data) => {
-  const result = { ...data };
-  if (data.project) {
-    result.val = structuredClone(data.project);
-    delete result.project;
-  }
-  return result;
-}); // Silently inject the Val field, to prepare for future migration
+export const VTStateSchema = z
+  .object({
+    project: z
+      .object({
+        id: z.string().uuid(),
+      })
+      .optional(),
+    val: z
+      .object({
+        id: z.string().uuid(),
+        // Project -> Val migration: This lets old meta.jsons that have a project.id
+        // still parse, and we transform them below. That means this ID is always
+        // populated.
+      })
+      .catch({ id: "" }),
+    branch: z.object({
+      id: z.string().uuid(),
+      version: z.number().gte(0),
+    }),
+    lastRun: z.object({
+      pid: z.number().gte(0),
+      time: z.string().refine((val) => !isNaN(Date.parse(val)), {}),
+    }),
+  })
+  .transform((data) => {
+    const result = { ...data };
+    if (data.project) {
+      result.val = structuredClone(data.project);
+      delete result.project;
+    }
+    return result;
+  }); // Silently inject the Val field, to prepare for future migration
 
 /**
  * JSON schema for the config.yaml file for configuration storage.
  */
 export const VTConfigSchema = z.object({
-  apiKey: z.string()
+  apiKey: z
+    .string()
     .refine((val) => val === null || val.length === 32 || val.length === 33, {
       message: "API key must be 32-33 characters long when provided",
     })
     .nullable(),
-  globalIgnoreFiles: z.preprocess(
-    (input) => {
+  globalIgnoreFiles: z
+    .preprocess((input) => {
       if (typeof input === "string") {
-        return input.split(",").map((s) => s.trim()).filter(Boolean);
+        return input
+          .split(",")
+          .map((s) => s.trim())
+          .filter(Boolean);
       }
       return input;
-    },
-    z.array(z.string()),
-  ).optional(),
-  dangerousOperations: z.object({
-    confirmation: z.union([
-      z.boolean(),
-      z.enum(["true", "false"]).transform((val) => val === "true"),
-    ]),
-  }).optional(),
+    }, z.array(z.string()))
+    .optional(),
+  dangerousOperations: z
+    .object({
+      confirmation: z.union([
+        z.boolean(),
+        z.enum(["true", "false"]).transform((val) => val === "true"),
+      ]),
+    })
+    .optional(),
   editorTemplate: z.string().optional(), // a Val URI
 });
 
@@ -74,3 +87,8 @@ export const DefaultVTConfig: z.infer<typeof VTConfigSchema> = {
   },
   editorTemplate: DEFAULT_EDITOR_TEMPLATE,
 };
+
+export const VTCheckCacheFile = z.object({
+  [SAW_AS_LATEST_VERSION]: z.string().optional(),
+  [AUTH_CACHE_LOCALSTORE_ENTRY]: z.coerce.date().optional(),
+});

src/vt/vt/schemas.ts

@@ -2,25 +2,20 @@
 import "@std/dotenv/load";
 import { ensureGlobalVtConfig, globalConfig } from "~/vt/VTConfig.ts";
 import { onboardFlow } from "~/cmd/flows/onboard.ts";
-import {
-  API_KEY_KEY,
-  AUTH_CACHE_LOCALSTORE_ENTRY,
-  AUTH_CACHE_TTL,
-} from "~/consts.ts";
+import { API_KEY_KEY, AUTH_CACHE_TTL } from "~/consts.ts";
 import { colors } from "@cliffy/ansi/colors";
 import sdk from "~/sdk.ts";
 import { registerOutdatedWarning } from "~/cmd/upgrade.ts";
-import { vtState } from "~/vt/VTState.ts";
+import { vtCheckCache } from "~/vt/VTCheckCache.ts";
 
 await ensureGlobalVtConfig();
 
 async function isApiKeyValid(): Promise<boolean> {
   // Since we run this on every invocation of vt, it makes sense to only check
   // if the api key is still valid every so often.
-
-  const lastAuthAt = await vtState.getItem(AUTH_CACHE_LOCALSTORE_ENTRY);
+  const lastAuthAt = await vtCheckCache.getAuthChecked();
   const hoursSinceLastAuth = lastAuthAt
-    ? new Date().getTime() - new Date(lastAuthAt).getTime()
+    ? new Date().getTime() - lastAuthAt.getTime()
     : Infinity;
   if (hoursSinceLastAuth < AUTH_CACHE_TTL) return true;
 
@@ -32,10 +27,7 @@ async function isApiKeyValid(): Promise<boolean> {
   });
 
   if (resp.ok) {
-    await vtState.setItem(
-      AUTH_CACHE_LOCALSTORE_ENTRY,
-      new Date().toISOString(),
-    );
+    await vtCheckCache.setAuthCheckedToNow();
     return true;
   }