fix: try fetch the sketch by path if not in the cache

arduino-ide-extension/src/browser/create/create-api.ts

@@ -57,6 +57,30 @@ export class CreateApi {
     return result;
   }
 
+  /**
+   * `sketchPath` is not the POSIX path but the path with the user UUID, username, etc.
+   * See [Create.Resource#path](./typings.ts). If `cache` is `true` and a sketch exists with the path,
+   * the cache will be updated with the new state of the sketch.
+   */
+  // TODO: no nulls in API
+  async sketchByPath(
+    sketchPath: string,
+    cache = false
+  ): Promise<Create.Sketch | null> {
+    const url = new URL(`${this.domain()}/sketches/byPath/${sketchPath}`);
+    const headers = await this.headers();
+    const sketch = await this.run<Create.Sketch>(url, {
+      method: 'GET',
+      headers,
+    });
+    if (sketch && cache) {
+      this.sketchCache.addSketch(sketch);
+      const posixPath = createPaths.toPosixPath(sketch.path);
+      this.sketchCache.purgeByPath(posixPath);
+    }
+    return sketch;
+  }
+
   async sketches(limit = 50): Promise<Create.Sketch[]> {
     const url = new URL(`${this.domain()}/sketches`);
     url.searchParams.set('user_id', 'me');
@@ -86,7 +110,11 @@ export class CreateApi {
 
   async createSketch(
     posixPath: string,
-    contentProvider: MaybePromise<string> = this.sketchesService.defaultInoContent()
+    contentProvider: MaybePromise<string> = this.sketchesService.defaultInoContent(),
+    payloadOverride: Record<
+      string,
+      string | boolean | number | Record<string, unknown>
+    > = {}
   ): Promise<Create.Sketch> {
     const url = new URL(`${this.domain()}/sketches`);
     const [headers, content] = await Promise.all([
@@ -97,6 +125,7 @@ export class CreateApi {
       ino: btoa(content),
       path: posixPath,
       user_id: 'me',
+      ...payloadOverride,
     };
     const init = {
       method: 'PUT',
@@ -212,7 +241,17 @@ export class CreateApi {
         return data;
       }
 
-      const sketch = this.sketchCache.getSketch(createPaths.parentPosix(path));
+      const posixPath = createPaths.parentPosix(path);
+      let sketch = this.sketchCache.getSketch(posixPath);
+      // Workaround for https://github.com/arduino/arduino-ide/issues/1999.
+      if (!sketch) {
+        // Convert the ordinary sketch POSIX path to the Create path.
+        // For example, `/sketch_apr6a` will be transformed to `8a694e4b83878cc53472bd75ee928053:kittaakos/sketches_v2/sketch_apr6a`.
+        const createPathPrefix = this.sketchCache.createPathPrefix;
+        if (createPathPrefix) {
+          sketch = await this.sketchByPath(createPathPrefix + posixPath, true);
+        }
+      }
 
       if (
         sketch &&
@@ -448,13 +487,18 @@ export class CreateApi {
     await this.run(url, init, ResponseResultProvider.NOOP);
   }
 
+  private fetchCounter = 0;
   private async run<T>(
     requestInfo: URL,
     init: RequestInit | undefined,
     resultProvider: ResponseResultProvider = ResponseResultProvider.JSON
   ): Promise<T> {
-    console.debug(`HTTP ${init?.method}: ${requestInfo.toString()}`);
+    const fetchCount = `[${++this.fetchCounter}]`;
+    const fetchStart = performance.now();
+    const method = init?.method ? `${init.method}: ` : '';
+    const url = requestInfo.toString();
     const response = await fetch(requestInfo.toString(), init);
+    const fetchEnd = performance.now();
     if (!response.ok) {
       let details: string | undefined = undefined;
       try {
@@ -465,7 +509,18 @@ export class CreateApi {
       const { statusText, status } = response;
       throw new CreateError(statusText, status, details);
     }
+    const parseStart = performance.now();
     const result = await resultProvider(response);
+    const parseEnd = performance.now();
+    console.debug(
+      `HTTP ${fetchCount} ${method} ${url} [fetch: ${(
+        fetchEnd - fetchStart
+      ).toFixed(2)} ms, parse: ${(parseEnd - parseStart).toFixed(
+        2
+      )} ms] body: ${
+        typeof result === 'string' ? result : JSON.stringify(result)
+      }`
+    );
     return result;
   }
 

arduino-ide-extension/src/browser/widgets/cloud-sketchbook/cloud-sketch-cache.ts

@@ -1,12 +1,13 @@
 import { FileStat } from '@theia/filesystem/lib/common/files';
 import { injectable } from '@theia/core/shared/inversify';
-import { toPosixPath } from '../../create/create-paths';
+import { splitSketchPath } from '../../create/create-paths';
 import { Create } from '../../create/typings';
 
 @injectable()
 export class SketchCache {
   sketches: Record<string, Create.Sketch> = {};
   fileStats: Record<string, FileStat> = {};
+  private _createPathPrefix: string | undefined;
 
   init(): void {
     // reset the data
@@ -32,14 +33,21 @@ export class SketchCache {
 
   addSketch(sketch: Create.Sketch): void {
     const { path } = sketch;
-    const posixPath = toPosixPath(path);
+    const [pathPrefix, posixPath] = splitSketchPath(path);
+    if (pathPrefix !== this._createPathPrefix) {
+      this._createPathPrefix = pathPrefix;
+    }
     this.sketches[posixPath] = sketch;
   }
 
   getSketch(path: string): Create.Sketch | null {
     return this.sketches[path] || null;
   }
 
+  get createPathPrefix(): string | undefined {
+    return this._createPathPrefix;
+  }
+
   toString(): string {
     return JSON.stringify({
       sketches: this.sketches,

arduino-ide-extension/src/test/browser/create-api.test.ts

@@ -1,6 +1,7 @@
 import { Container, ContainerModule } from '@theia/core/shared/inversify';
 import { assert, expect } from 'chai';
 import fetch from 'cross-fetch';
+import { posix } from 'path';
 import { v4 } from 'uuid';
 import { ArduinoPreferences } from '../../browser/arduino-preferences';
 import { AuthenticationClientService } from '../../browser/auth/authentication-client-service';
@@ -251,6 +252,39 @@ describe('create-api', () => {
       expect(sketch).to.be.undefined;
     });
   });
+
+  it("should fetch the sketch when transforming the 'secrets' into '#include' and the sketch is not in the cache", async () => {
+    const name = v4();
+    const posixPath = toPosix(name);
+    const newSketch = await createApi.createSketch(
+      posixPath,
+      'void setup(){} void loop(){}',
+      {
+        secrets: {
+          data: [
+            {
+              name: 'SECRET_THING',
+              value: '❤︎',
+            },
+          ],
+        },
+      }
+    );
+    expect(newSketch).to.be.not.undefined;
+    expect(newSketch.secrets).to.be.not.undefined;
+    expect(Array.isArray(newSketch.secrets)).to.be.true;
+    expect(newSketch.secrets?.length).to.be.equal(1);
+    expect(newSketch.secrets?.[0]).to.be.deep.equal({
+      name: 'SECRET_THING',
+      value: '❤︎',
+    });
+    createApi.sketchCache.init(); // invalidate the cache
+    const content = await createApi.readFile(
+      posix.join(posixPath, `${name}.ino`)
+    );
+    expect(content.includes(`#include "${Create.arduino_secrets_file}"`)).to.be
+      .true;
+  });
 });
 
 // Using environment variables is recommended for testing but you can modify the module too.