handle session keys in file

Signed-off-by: shmck <shawn.j.mckay@gmail.com>

src/services/node/index.ts

@@ -14,26 +14,34 @@ interface ExecParams {
   dir?: string
 }
 
+// correct paths to be from workspace root rather than extension folder
+const getWorkspacePath = (...paths: string[]) => {
+  return join(WORKSPACE_ROOT, ...paths)
+}
+
 export const exec = (params: ExecParams): Promise<{ stdout: string; stderr: string }> | never => {
   const cwd = join(WORKSPACE_ROOT, params.dir || '')
   return asyncExec(params.command, { cwd })
 }
 
 export const exists = (...paths: string[]): boolean | never => {
-  return fs.existsSync(join(WORKSPACE_ROOT, ...paths))
+  return fs.existsSync(getWorkspacePath(...paths))
 }
 
 export const removeFile = (...paths: string[]) => {
-  return asyncRemoveFile(join(WORKSPACE_ROOT, ...paths))
+  return asyncRemoveFile(getWorkspacePath(...paths))
 }
 
-export const readFile = (...paths: string[]) => {
-  return asyncReadFile(join(...paths), 'utf8')
+export const readFile = (...paths: string[]): Promise<string | void> => {
+  const filePath = getWorkspacePath(...paths)
+  return asyncReadFile(getWorkspacePath(...paths), 'utf8').catch((err) => {
+    console.warn(`Failed to read from ${filePath}`)
+  })
 }
 
-export const writeFile = (data: any, ...paths: string[]) => {
-  const filePath = join(...paths)
+export const writeFile = (data: any, ...paths: string[]): Promise<void> => {
+  const filePath = getWorkspacePath(...paths)
   return asyncWriteFile(filePath, JSON.stringify(data)).catch((err) => {
-    console.error(`Failed to write to ${filePath}`)
+    console.warn(`Failed to write to ${filePath}`)
   })
 }

src/services/storage/index.ts

@@ -22,36 +22,53 @@ class Storage<T> {
     if (value) {
       return JSON.parse(value)
     } else if (SESSION_FILE_PATH) {
-      // optionally read from file as a fallback to localstorage
-      const sessionFile = await readFile(SESSION_FILE_PATH)
       try {
+        // optionally read from file as a fallback to local storage
+        const sessionFile = await readFile(SESSION_FILE_PATH)
+        if (!sessionFile) {
+          throw new Error('No session file found')
+        }
         const session = JSON.parse(sessionFile)
-        if (session && session[this.key]) {
-          // TODO: validate session
-          return session[this.key]
+
+        if (session) {
+          const keys = Object.keys(session)
+          // validate session
+          if (keys.length) {
+            // should only be one
+            this.key = keys[0]
+            return session[this.key]
+          }
         }
       } catch (err) {
-        console.error(`Failed to parse session file: ${SESSION_FILE_PATH}`)
+        console.warn(`Failed to read or parse session file: ${SESSION_FILE_PATH}`)
       }
     }
     return this.defaultValue
   }
   public set = (value: T): void => {
     const stringValue = JSON.stringify(value)
     this.storage.update(this.key, stringValue)
+    this.writeToSessionFile(stringValue)
   }
   public update = async (value: T): Promise<void> => {
     const current = await this.get()
     const next = JSON.stringify({
       ...current,
       ...value,
     })
-    this.storage.update(this.key, next).then(() => {
-      // optionally write to file
-      if (SESSION_FILE_PATH) {
-        writeFile(this.storage, SESSION_FILE_PATH)
+    await this.storage.update(this.key, next)
+
+    this.writeToSessionFile(next)
+  }
+  public writeToSessionFile(data: string) {
+    // optionally write to file
+    if (SESSION_FILE_PATH) {
+      try {
+        writeFile({ [this.key]: data }, SESSION_FILE_PATH)
+      } catch (err: any) {
+        console.warn(`Failed to write coderoad session to path: ${SESSION_FILE_PATH}`)
       }
-    })
+    }
   }
   public reset = () => {
     this.set(this.defaultValue)