@akanjs/devkit 3.1.0-rc.0 → 3.1.0-rc.1

package/cloud/cloudApi.ts

@@ -184,6 +184,8 @@ export class CloudApi {
       target: string;
       distribution: AppBinaryDistribution;
       bundle: Blob;
+      /** The pack staged with UpdatePackUpload.stage; the multipart `pack` is for a server older than staging. */
+      packUploadId?: string;
       pack?: Blob;
       channel?: string;
     },
@@ -192,8 +194,11 @@ export class CloudApi {
     for (const key of ["appName", "target", "distribution"] as const) formData.append(key, binary[key]);
     if (binary.channel) formData.append("channel", binary.channel);
     formData.append("bundle", binary.bundle, "bundle.json");
+    if (binary.packUploadId) formData.append("packUploadId", binary.packUploadId);
     if (binary.pack) formData.append("pack", binary.pack, "pack.tgz");
-    return await this.#api.post<CloudRecord>(`/registerAppBinary/${encodeURIComponent(devProjectId)}`, formData);
+    return await this.#api.post<CloudRecord>(`/registerAppBinary/${encodeURIComponent(devProjectId)}`, formData, {
+      signal: AbortSignal.timeout(11 * 60_000),
+    });
   }
   async downloadEnv(devProjectId: string): Promise<unknown> {
     const localPath = `${this.#workspace.workspaceRoot}/local/env.tar`;

package/cloud/updatePackUpload.test.ts

@@ -18,8 +18,9 @@ class FakeAkasys {
   readonly requests: Record<string, unknown>[] = [];
   readonly puts: Put[] = [];
   readonly commits: string[] = [];
+  readonly registrations: Record<string, string>[] = [];
   putStatuses: number[] = [];
-  commitAnswers: number[] = [];
+  commitAnswers: (number | [number, string])[] = [];
   release: Record<string, unknown> = { id: "release-1", status: "published", problems: [] };
   requestRefusal: Response | null = null;
 
@@ -35,6 +36,7 @@ class FakeAkasys {
     this.requests.length = 0;
     this.puts.length = 0;
     this.commits.length = 0;
+    this.registrations.length = 0;
     this.putStatuses = [];
     this.commitAnswers = [];
     this.requestRefusal = null;
@@ -64,12 +66,28 @@ class FakeAkasys {
     if (url.pathname === "/api/commitUpdateUpload/project-1") {
       const { uploadId } = (await request.json()) as { uploadId: string };
       this.commits.push(uploadId);
-      const answer = this.commitAnswers.shift();
-      if (answer) return Response.json({ error: "release.error.uploadCommitInProgress" }, { status: answer });
+      const answer = this.#answer();
+      if (answer) return answer;
       return Response.json({ ...this.release, uploadId });
     }
+    if (url.pathname === "/api/registerAppBinary/project-1") {
+      const form = await request.formData();
+      this.registrations.push(
+        Object.fromEntries(
+          [...form.entries()].map(([key, value]) => [key, typeof value === "string" ? value : "<file>"]),
+        ),
+      );
+      return this.#answer() ?? Response.json({ id: "binary-1" });
+    }
     return new Response("not found", { status: 404 });
   }
+
+  #answer() {
+    const answer = this.commitAnswers.shift();
+    if (!answer) return null;
+    const [status, key] = typeof answer === "number" ? [answer, "release.error.uploadCommitInProgress"] : answer;
+    return Response.json({ error: key }, { status });
+  }
 }
 
 const makeDir = tempDirs("akan-update-upload-");
@@ -187,6 +205,43 @@ describe("UpdatePackUpload", () => {
     expect(akasys.puts).toEqual([]);
   });
 
+  test("stops at once on a 409 that is not a commit in progress: the upload is already used", async () => {
+    const archive = await archiveOf("pack");
+    akasys.commitAnswers = [[409, "release.error.uploadEmbedded"]];
+    await expect(new UpdatePackUpload(api, "project-1", quick).send(archive, fields)).rejects.toThrow("uploadEmbedded");
+    expect(akasys.commits).toHaveLength(1);
+  });
+
+  test("stages a binary's pack and registers it by upload id, asking again while the server is still at it", async () => {
+    const archive = await archiveOf("pack");
+    akasys.commitAnswers = [524, 409];
+    const upload = new UpdatePackUpload(api, "project-1", quick);
+    const binary = await upload.stage(archive, fields).then((packUploadId) =>
+      upload.settle(() =>
+        api.registerAppBinary("project-1", {
+          appName: "lu",
+          target: "default",
+          distribution: "playTesting",
+          bundle: new Blob(["{}"]),
+          packUploadId,
+          channel: "develop",
+        }),
+      ),
+    );
+
+    expect(binary).toEqual({ id: "binary-1" });
+    expect(akasys.commits).toEqual([]);
+    expect(akasys.registrations).toHaveLength(3);
+    expect(akasys.registrations[2]).toEqual({
+      appName: "lu",
+      target: "default",
+      distribution: "playTesting",
+      channel: "develop",
+      bundle: "<file>",
+      packUploadId: "upload-1",
+    });
+  });
+
   test("refuses an empty archive before asking for a ticket", async () => {
     const archive = await archiveOf("");
     await expect(new UpdatePackUpload(api, "project-1", quick).send(archive, fields)).rejects.toThrow("0 bytes");

package/cloud/updatePackUpload.ts

@@ -10,7 +10,8 @@ interface UpdatePackUploadOptions {
 }
 
 //* akasys sits behind Cloudflare's 100 s request cut, so the pack goes straight to its staging bucket and akasys
-//* only sees two small JSON calls: request a presigned PUT, then commit the object, which akasys re-hashes.
+//* only sees small calls: request a presigned PUT, then commit the object, or register a binary with it as its
+//* embedded pack; either re-hashes it, and an upload is used once, one way.
 export class UpdatePackUpload {
   static readonly maxBytes = 200 * 1024 * 1024;
   static readonly #transientPut = new Set([0, 408, 429, 500, 502, 503, 504]);
@@ -39,7 +40,14 @@ export class UpdatePackUpload {
     this.#commitLimitMs = commitLimitMs;
   }
 
+  /** Stages the pack and commits it as a release of `fields.channel`. */
   async send(archive: string, fields: Omit<UpdateUploadRequest, "size" | "sha256">): Promise<CloudRecord> {
+    const uploadId = await this.stage(archive, fields);
+    return await this.settle(() => this.#api.commitUpdateUpload(this.#devProjectId, uploadId));
+  }
+
+  /** Puts the pack in the project's staging storage and answers the upload id a commit or a registration names. */
+  async stage(archive: string, fields: Omit<UpdateUploadRequest, "size" | "sha256">): Promise<string> {
     const file = Bun.file(archive);
     if (file.size < 1 || file.size > UpdatePackUpload.maxBytes)
       throw new Error(`The pack archive is ${file.size} bytes; a project takes 1 byte to 200 MiB.`);
@@ -50,7 +58,7 @@ export class UpdatePackUpload {
     for (let ticket = 1; ; ticket++) {
       const { uploadId, uploadUrl, contentType } = await this.#request(upload);
       const status = await this.#put(uploadUrl, contentType, file);
-      if (status >= 200 && status < 300) return await this.#commit(uploadId);
+      if (status >= 200 && status < 300) return uploadId;
       if (status !== 403 || ticket === 2)
         throw new Error(`The storage refused the pack upload (${status ? `HTTP ${status}` : "no response"}).`);
     }
@@ -83,18 +91,21 @@ export class UpdatePackUpload {
     }
   }
 
-  // The server finishes a commit whoever stopped listening, and the same id answers the same release afterwards.
-  // A 409 is a live claim the server heartbeats, so only the overall limit bounds it; a run of cut-offs with no 409
-  // between them may be a server that died, whose claim lapses within minutes, so that run gets the shorter window.
-  async #commit(uploadId: string) {
+  /**
+   * Sends `call`, which consumes a staged upload, until the server answers it: the server finishes whoever stopped
+   * listening, and the same upload id answers the same record afterwards.
+   */
+  // `uploadCommitInProgress` is a live claim the server heartbeats, so only the overall limit bounds it; a run of
+  // cut-offs with none between them may be a server that died, whose claim lapses within minutes: the shorter window.
+  async settle<T>(call: () => Promise<T>): Promise<T> {
     const limit = performance.now() + this.#commitLimitMs;
     let cutOffSince: number | null = null;
     for (;;) {
       try {
-        return await this.#api.commitUpdateUpload(this.#devProjectId, uploadId);
+        return await call();
       } catch (error) {
         const now = performance.now();
-        if (CloudApi.statusOf(error) === 409) cutOffSince = null;
+        if (UpdatePackUpload.#inProgress(error)) cutOffSince = null;
         else if (UpdatePackUpload.#cutOff(error)) cutOffSince ??= now;
         else throw error;
         const deadline = cutOffSince === null ? limit : Math.min(limit, cutOffSince + this.#cutOffWindowMs);
@@ -107,6 +118,12 @@ export class UpdatePackUpload {
     }
   }
 
+  //? Not every 409: an upload already committed or embedded is answered 409 too, and asking again changes nothing.
+  static #inProgress(error: unknown) {
+    const message = error instanceof Error ? error.message : String(error);
+    return CloudApi.statusOf(error) === 409 && message.includes("uploadCommitInProgress");
+  }
+
   static #cutOff(error: unknown) {
     const status = CloudApi.statusOf(error);
     if (status === null) return !(error instanceof SyntaxError);

package/mobile/nativeApp.test.ts

@@ -232,3 +232,36 @@ describe("NativeApp", () => {
     );
   });
 });
+
+describe("a pack read back from its folder", () => {
+  test("takes the folder as the pack's place, and refuses what is not a takeable pack", async () => {
+    const root = await makeTempRoot();
+    const pack = {
+      schema: 1,
+      app: "lu",
+      target: "default",
+      platform: "android",
+      env: "main",
+      channel: "main",
+      appId: "com.lu",
+      appVersion: "1.0.0",
+      nativeApi: "0123456789abcdef",
+      webHash: "f".repeat(64),
+      files: 1,
+      size: 13,
+      out: "/elsewhere/updates/android",
+    };
+    const moved = path.join(root, "moved");
+    await writeText(path.join(moved, "pack.json"), JSON.stringify(pack));
+    expect(await NativeApp.readPack(moved)).toEqual({ ...pack, out: moved } as never);
+
+    await expect(NativeApp.readPack(path.join(root, "empty"))).rejects.toThrow("holds no pack.json");
+    const later = path.join(root, "later");
+    await writeText(path.join(later, "pack.json"), JSON.stringify({ ...pack, schema: 2 }));
+    await expect(NativeApp.readPack(later)).rejects.toThrow("schema 2");
+    const refused = path.join(root, "refused");
+    const compat = { against: "store/bundle.json", compatible: false, problems: ["deepLinks differ"] };
+    await writeText(path.join(refused, "pack.json"), JSON.stringify({ ...pack, compat }));
+    expect((await NativeApp.readPack(refused)).compat).toEqual(compat);
+  });
+});

package/mobile/nativeApp.ts

@@ -467,6 +467,16 @@ export class NativeApp {
     await Bun.write(path.join(pack.out, "pack.json"), `${JSON.stringify(pack, null, 2)}\n`);
   }
 
+  /** A pack `packUpdate` wrote, read back from its folder wherever it was moved. */
+  static async readPack(dir: string): Promise<NativeUpdatePack> {
+    const file = Bun.file(path.join(dir, "pack.json"));
+    if (!(await file.exists()))
+      throw new Error(`${dir} holds no pack.json: give the folder \`akan pack-update\` wrote.`);
+    const pack = (await file.json()) as NativeUpdatePack;
+    if (pack.schema !== 1) throw new Error(`${dir}/pack.json is schema ${pack.schema}, and this akan reads schema 1.`);
+    return { ...pack, out: path.resolve(dir) };
+  }
+
   static async compareBundles(appDir: string, shipped: string, bundle: string) {
     return (await NativeApi.load(appDir)).compareBundles(shipped, bundle);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akanjs/devkit",
-  "version": "3.1.0-rc.0",
+  "version": "3.1.0-rc.1",
   "sourceType": "module",
   "type": "module",
   "publishConfig": {
@@ -48,7 +48,7 @@
     "@earendil-works/pi-tui": "0.86.1",
     "@inquirer/prompts": "^8.4.3",
     "@tailwindcss/node": "^4.3.0",
-    "akanjs": "3.1.0-rc.0",
+    "akanjs": "3.1.0-rc.1",
     "chalk": "^5.6.2",
     "commander": "^14.0.3",
     "dayjs": "^1.11.20",