@solana-mobile/dapp-store-cli 0.15.0 → 0.16.1

package/src/portal/__tests__/workflowClient.test.ts

@@ -0,0 +1,278 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+import { afterEach, beforeEach, expect, jest, test } from "@jest/globals";
+
+import { createPortalWorkflowClient } from "../workflowClient.js";
+
+function createProcedureResponse(result: unknown): Response {
+  return new Response(JSON.stringify({ result: { data: result } }), {
+    status: 200,
+    headers: {
+      "content-type": "application/json",
+    },
+  });
+}
+
+let originalFetch: typeof fetch;
+let fetchMock: jest.MockedFunction<typeof fetch>;
+const tempDirs: string[] = [];
+
+beforeEach(() => {
+  originalFetch = global.fetch;
+  fetchMock = jest.fn<typeof fetch>();
+  global.fetch = fetchMock as typeof fetch;
+});
+
+afterEach(() => {
+  global.fetch = originalFetch;
+  while (tempDirs.length > 0) {
+    fs.rmSync(tempDirs.pop()!, { recursive: true, force: true });
+  }
+});
+
+test("createIngestionSession maps apk-url sources to the portal externalUrl API shape", async () => {
+  fetchMock.mockResolvedValueOnce(
+    createProcedureResponse({
+      id: "ingestion-1",
+      dappId: "dapp-1",
+      idempotencyKey: "idem-1",
+      status: "Created",
+      sourceKind: "externalUrl",
+      sourceUrl: "https://downloads.example.com/releases/app-release.apk",
+      releaseFileName: "app-release.apk",
+      releaseFileSize: 10,
+      releaseId: "release-1",
+      publicationSessionId: "session-1",
+      bundle: {
+        release: {
+          id: "release-1",
+          releaseFileName: "app-release.apk",
+          versionCode: 42,
+          versionName: "42",
+          androidPackage: "com.example.app",
+          localizedName: "Example App",
+          newInVersion: "Fixes",
+        },
+        dapp: {
+          id: "dapp-1",
+          dappName: "Example App",
+          description: "A dApp",
+          walletAddress: "wallet-1",
+          androidPackage: "com.example.app",
+        },
+        publisher: {
+          id: "publisher-1",
+          type: "organization",
+          name: "Example Publisher",
+          website: "https://example.com",
+          email: "team@example.com",
+        },
+        installFile: {
+          uri: "https://downloads.example.com/releases/app-release.apk",
+          size: 10,
+        },
+        signerAuthority: {
+          dappWalletAddress: "wallet-1",
+          collectionAuthority: "wallet-1",
+        },
+      },
+      publicationSession: {
+        id: "session-1",
+        releaseId: "release-1",
+        stage: "PreparedForMint",
+        created: "2024-01-01T00:00:00.000Z",
+        updated: "2024-01-01T00:00:00.000Z",
+      },
+    })
+  );
+
+  const client = createPortalWorkflowClient({
+    apiBaseUrl: "https://portal.example.com/api",
+    apiKey: "portal-key",
+  });
+
+  const result = await client.createIngestionSession({
+    source: {
+      kind: "apk-url",
+      url: "https://downloads.example.com/releases/app-release.apk",
+    },
+    whatsNew: "Fixes",
+    idempotencyKey: "idem-1",
+  });
+
+  const [requestUrl, requestInit] = fetchMock.mock.calls[0]!;
+  const requestBody = JSON.parse(String(requestInit?.body));
+
+  expect(String(requestUrl)).toContain(
+    "/trpc/publication.createIngestionSession"
+  );
+  expect(requestInit?.method).toBe("POST");
+  expect(requestBody).toMatchObject({
+    source: {
+      kind: "externalUrl",
+      apkUrl: "https://downloads.example.com/releases/app-release.apk",
+      releaseFileName: "app-release.apk",
+    },
+    whatsNew: "Fixes",
+    idempotencyKey: "idem-1",
+  });
+  expect(result.source.kind).toBe("apk-url");
+  expect(result.bundle?.metadata?.installFile.origin).toBe("external");
+  expect(result.publicationSession?.checkpoint).toBe("bundle-ready");
+});
+
+test("createIngestionSession uploads local APK files before creating the ingestion session", async () => {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "dapp-store-apk-"));
+  const apkPath = path.join(tempDir, "release-build");
+  tempDirs.push(tempDir);
+  fs.writeFileSync(apkPath, Buffer.from("apk-binary"));
+
+  fetchMock
+    .mockResolvedValueOnce(
+      createProcedureResponse({
+        uploadUrl: "https://uploads.example.com/app.apk",
+        key: "upload-key",
+        providerId: "provider-1",
+        publicUrl: "https://cdn.example.com/app.apk",
+      })
+    )
+    .mockResolvedValueOnce(new Response("", { status: 200 }))
+    .mockResolvedValueOnce(
+      createProcedureResponse({
+        id: "ingestion-2",
+        dappId: "dapp-1",
+        idempotencyKey: "idem-2",
+        status: "Created",
+        sourceKind: "portalUpload",
+        sourceUrl: "https://cdn.example.com/app.apk",
+        releaseFileName: "release-build.apk",
+        releaseFileSize: 10,
+        releaseId: "release-2",
+        publicationSessionId: "session-2",
+        bundle: {
+          release: {
+            id: "release-2",
+            releaseFileName: "release-build.apk",
+            releaseFileUrl: "https://cdn.example.com/app.apk",
+            versionCode: 7,
+            versionName: "7",
+            androidPackage: "com.example.app",
+            localizedName: "Example App",
+            newInVersion: "Local upload",
+          },
+          dapp: {
+            id: "dapp-1",
+            dappName: "Example App",
+            description: "A dApp",
+            walletAddress: "wallet-1",
+            androidPackage: "com.example.app",
+          },
+          publisher: {
+            id: "publisher-1",
+            type: "organization",
+            name: "Example Publisher",
+            website: "https://example.com",
+            email: "team@example.com",
+          },
+          installFile: {
+            uri: "https://cdn.example.com/app.apk",
+            size: 10,
+          },
+          signerAuthority: {
+            dappWalletAddress: "wallet-1",
+            collectionAuthority: "wallet-1",
+          },
+        },
+        publicationSession: {
+          id: "session-2",
+          releaseId: "release-2",
+          stage: "PreparedForMint",
+          created: "2024-01-01T00:00:00.000Z",
+          updated: "2024-01-01T00:00:00.000Z",
+        },
+      })
+    );
+
+  const client = createPortalWorkflowClient({
+    apiBaseUrl: "https://portal.example.com/api",
+    apiKey: "portal-key",
+  });
+
+  const result = await client.createIngestionSession({
+    source: {
+      kind: "apk-file",
+      filePath: apkPath,
+    },
+    whatsNew: "Local upload",
+    idempotencyKey: "idem-2",
+  });
+
+  const [uploadTargetUrl, uploadTargetInit] = fetchMock.mock.calls[0]!;
+  const uploadTargetBody = JSON.parse(String(uploadTargetInit?.body));
+  expect(String(uploadTargetUrl)).toContain(
+    "/trpc/publication.createUploadTarget"
+  );
+  expect(uploadTargetBody).toMatchObject({
+    fileExtension: "apk",
+    contentType: "application/vnd.android.package-archive",
+  });
+
+  const [uploadUrl, uploadInit] = fetchMock.mock.calls[1]!;
+  expect(String(uploadUrl)).toBe("https://uploads.example.com/app.apk");
+  expect(uploadInit?.method).toBe("PUT");
+  expect(Buffer.from(uploadInit?.body as Uint8Array).toString()).toBe(
+    "apk-binary"
+  );
+
+  const [ingestionUrl, ingestionInit] = fetchMock.mock.calls[2]!;
+  const ingestionBody = JSON.parse(String(ingestionInit?.body));
+  expect(String(ingestionUrl)).toContain(
+    "/trpc/publication.createIngestionSession"
+  );
+  expect(ingestionBody).toMatchObject({
+    source: {
+      kind: "portalUpload",
+      releaseFileUrl: "https://cdn.example.com/app.apk",
+      releaseFileName: "release-build.apk",
+      releaseFileSize: 10,
+    },
+    whatsNew: "Local upload",
+    idempotencyKey: "idem-2",
+  });
+
+  expect(result.source.kind).toBe("apk-file");
+  expect(result.bundle?.metadata?.installFile.origin).toBe("portal");
+  expect(result.releaseId).toBe("release-2");
+  expect(result.publicationSessionId).toBe("session-2");
+});
+
+test("createIngestionSession explains local file permission errors", async () => {
+  const readFileSpy = jest.spyOn(fs, "readFileSync").mockImplementation(() => {
+    const error = Object.assign(new Error("operation not permitted"), {
+      code: "EPERM",
+    });
+    throw error;
+  });
+
+  const client = createPortalWorkflowClient({
+    apiBaseUrl: "https://portal.example.com/api",
+    apiKey: "portal-key",
+  });
+
+  await expect(
+    client.createIngestionSession({
+      source: {
+        kind: "apk-file",
+        filePath: "/Users/skumail/Downloads/app.apk",
+      },
+      whatsNew: "Local upload",
+      idempotencyKey: "idem-3",
+    })
+  ).rejects.toThrow(
+    "Move the APK out of Downloads into your workspace or another accessible folder"
+  );
+
+  readFileSpy.mockRestore();
+});

package/src/portal/attestationClient.ts

@@ -0,0 +1,19 @@
+import type { PublicationAttestationClient } from '@solana-mobile/dapp-store-publishing-tools';
+
+import { callPortalProcedure } from './http.js';
+import type { PortalClientConfig } from './types.js';
+
+export function createPortalAttestationClient(
+  config: PortalClientConfig,
+): PublicationAttestationClient {
+  return {
+    async getBlockData() {
+      return await callPortalProcedure<{ slot: number; blockhash: string }>(
+        config,
+        'attestation.getBlockData',
+        {},
+        'query',
+      );
+    },
+  };
+}

package/src/portal/files.ts

@@ -0,0 +1,73 @@
+export function ensureHttpsUrl(url: string): string {
+  const trimmed = url.trim();
+
+  if (!trimmed) {
+    return trimmed;
+  }
+
+  if (trimmed.startsWith("https://")) {
+    return trimmed;
+  }
+
+  if (trimmed.startsWith("http://")) {
+    return trimmed.replace(/^http:\/\//, "https://");
+  }
+
+  return `https://${trimmed}`;
+}
+
+export function inferFileNameFromUrl(url: string): string {
+  try {
+    const pathname = new URL(url).pathname;
+    const basename = pathname.split("/").filter(Boolean).pop();
+    return basename || "app-release.apk";
+  } catch {
+    return "app-release.apk";
+  }
+}
+
+export function inferFileExtension(fileName: string): string {
+  const extension = fileName.split(".").pop()?.trim().toLowerCase() || "apk";
+  return extension.replace(/[^a-z0-9]/g, "") || "apk";
+}
+
+export function ensureApkFileName(fileName: string): string {
+  return /\.apk$/i.test(fileName) ? fileName : `${fileName}.apk`;
+}
+
+export function inferMimeType(fileName: string): string {
+  const extension = inferFileExtension(fileName);
+  switch (extension) {
+    case "apk":
+      return "application/vnd.android.package-archive";
+    case "json":
+      return "application/json";
+    case "png":
+      return "image/png";
+    case "jpg":
+    case "jpeg":
+      return "image/jpeg";
+    case "webp":
+      return "image/webp";
+    case "gif":
+      return "image/gif";
+    case "svg":
+      return "image/svg+xml";
+    case "mp4":
+      return "video/mp4";
+    case "webm":
+      return "video/webm";
+    case "mov":
+      return "video/quicktime";
+    default:
+      return "application/octet-stream";
+  }
+}
+
+export function toBase64(buffer: Uint8Array): string {
+  return Buffer.from(buffer).toString("base64");
+}
+
+export function fromBase64(value: string): Uint8Array {
+  return new Uint8Array(Buffer.from(value, "base64"));
+}

package/src/portal/http.ts

@@ -0,0 +1,170 @@
+import {
+  type PortalClientConfig,
+  type PortalProcedureResult,
+} from './types.js';
+import { isRecord, readDeep } from './records.js';
+
+function unwrapPortalResult<T>(
+  result: PortalProcedureResult<T> | Record<string, unknown> | T,
+  fallbackMessage: string,
+): T {
+  if (isRecord(result) && '_tag' in result) {
+    const tagged = result as PortalProcedureResult<T>;
+    if (tagged._tag === 'Left') {
+      throw new Error(tagged.left.message || fallbackMessage);
+    }
+
+    return tagged.right;
+  }
+
+  return result as T;
+}
+
+export async function callPortalProcedure<T>(
+  config: PortalClientConfig,
+  procedure: string,
+  input: unknown,
+  method: 'query' | 'mutation' = 'mutation',
+): Promise<T> {
+  const baseUrl = config.apiBaseUrl.replace(/\/$/, '');
+  const url = new URL(`${baseUrl}/trpc/${procedure}`);
+  const headers: Record<string, string> = {
+    accept: 'application/json',
+    'x-api-key': config.apiKey,
+  };
+
+  let response: Response;
+  if (method === 'query') {
+    if (input !== undefined) {
+      url.searchParams.set('input', JSON.stringify(input));
+    }
+    response = await fetch(url, {
+      method: 'GET',
+      headers,
+    });
+  } else {
+    headers['content-type'] = 'application/json';
+    response = await fetch(url, {
+      method: 'POST',
+      headers,
+      body: input === undefined ? undefined : JSON.stringify(input),
+    });
+  }
+
+  const text = await response.text();
+  let payload: unknown;
+
+  try {
+    payload = text.length > 0 ? JSON.parse(text) : null;
+  } catch {
+    const preview =
+      text.replace(/\s+/g, ' ').trim().slice(0, 180) || '[empty]';
+    throw new Error(
+      `Failed to parse portal response from ${procedure}: ${preview}`,
+    );
+  }
+
+  const normalizedPayload =
+    isRecord(payload) && '0' in payload
+      ? (payload as Record<string, unknown>)['0']
+      : payload;
+
+  if (!response.ok) {
+    if (isRecord(normalizedPayload)) {
+      const error = readDeep(normalizedPayload, 'error.message');
+      if (typeof error === 'string' && error.length > 0) {
+        throw new Error(`${procedure}: ${error}`);
+      }
+
+      const nested = readDeep(normalizedPayload, 'result.data');
+      if (isRecord(nested) && nested._tag === 'Left') {
+        const left = nested as Extract<
+          PortalProcedureResult<T>,
+          { _tag: 'Left' }
+        >;
+        if (left.left.message) {
+          throw new Error(`${procedure}: ${left.left.message}`);
+        }
+      }
+    }
+
+    throw new Error(
+      `${procedure}: Portal request failed with status ${response.status}`,
+    );
+  }
+
+  const result =
+    readDeep(normalizedPayload, 'result.data') ??
+    readDeep(normalizedPayload, 'result');
+  return unwrapPortalResult(
+    result as PortalProcedureResult<T> | Record<string, unknown> | T,
+    `Portal request failed for ${procedure}`,
+  );
+}
+
+function isRetryableCreateIngestionSessionError(error: unknown): boolean {
+  const message =
+    error instanceof Error
+      ? error.message.toLowerCase()
+      : String(error).toLowerCase();
+
+  return (
+    message.includes(
+      'failed to parse portal response from publication.createingestionsession',
+    ) ||
+    message.includes('gateway timeout') ||
+    message.includes('bad gateway') ||
+    message.includes('service unavailable') ||
+    message.includes('unexpected token <')
+  );
+}
+
+export async function callCreateIngestionSessionWithRetry(
+  config: PortalClientConfig,
+  input: Record<string, unknown>,
+): Promise<Record<string, unknown>> {
+  let lastError: unknown;
+
+  for (let attempt = 0; attempt < 3; attempt += 1) {
+    try {
+      return await callPortalProcedure<Record<string, unknown>>(
+        config,
+        'publication.createIngestionSession',
+        input,
+        'mutation',
+      );
+    } catch (error) {
+      lastError = error;
+      if (!isRetryableCreateIngestionSessionError(error) || attempt === 2) {
+        throw error;
+      }
+
+      await new Promise((resolve) => setTimeout(resolve, 1500 * (attempt + 1)));
+    }
+  }
+
+  throw lastError instanceof Error
+    ? lastError
+    : new Error('Failed to create ingestion session');
+}
+
+export async function uploadBytes(
+  uploadUrl: string,
+  body: Uint8Array,
+  contentType: string,
+): Promise<void> {
+  const response = await fetch(uploadUrl, {
+    method: 'PUT',
+    headers: {
+      'content-type': contentType,
+    },
+    body,
+  });
+
+  if (!response.ok) {
+    const preview = (await response.text()).replace(/\s+/g, ' ').trim();
+    throw new Error(
+      `Failed to upload file to the portal: ${preview || response.statusText}`,
+    );
+  }
+}

package/src/portal/records.ts

@@ -0,0 +1,38 @@
+export function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null;
+}
+
+export function asRecord(
+  value: unknown,
+): Record<string, unknown> | undefined {
+  return isRecord(value) ? value : undefined;
+}
+
+export function readDeep(value: unknown, propertyPath: string): unknown {
+  const parts = propertyPath.split('.');
+  let current: unknown = value;
+
+  for (const part of parts) {
+    if (!isRecord(current)) {
+      return undefined;
+    }
+
+    current = current[part];
+  }
+
+  return current;
+}
+
+export function firstString(
+  value: unknown,
+  paths: string[],
+): string | undefined {
+  for (const propertyPath of paths) {
+    const candidate = readDeep(value, propertyPath);
+    if (typeof candidate === 'string' && candidate.trim().length > 0) {
+      return candidate;
+    }
+  }
+
+  return undefined;
+}