@hot-updater/server 0.30.12 → 0.31.0

package/src/schema/v0_29_0.ts

@@ -11,7 +11,7 @@ export const v0_29_0 = schema({
       file_hash: column("file_hash", "string"),
       git_commit_hash: column("git_commit_hash", "string").nullable(),
       message: column("message", "string").nullable(),
-      channel: column("channel", "string"),
+      channel: column("channel", "string").defaultTo("production"),
       storage_uri: column("storage_uri", "string"),
       target_app_version: column("target_app_version", "string").nullable(),
       fingerprint_hash: column("fingerprint_hash", "string").nullable(),

package/src/schema/v0_31_0.ts

@@ -0,0 +1,58 @@
+import { column, idColumn, schema, table } from "fumadb/schema";
+
+export const v0_31_0 = schema({
+  version: "0.31.0",
+  tables: {
+    bundles: table("bundles", {
+      id: idColumn("id", "uuid"),
+      platform: column("platform", "string"),
+      should_force_update: column("should_force_update", "bool"),
+      enabled: column("enabled", "bool"),
+      file_hash: column("file_hash", "string"),
+      git_commit_hash: column("git_commit_hash", "string").nullable(),
+      message: column("message", "string").nullable(),
+      channel: column("channel", "string").defaultTo("production"),
+      storage_uri: column("storage_uri", "string"),
+      target_app_version: column("target_app_version", "string").nullable(),
+      fingerprint_hash: column("fingerprint_hash", "string").nullable(),
+      metadata: column("metadata", "json"),
+      manifest_storage_uri: column("manifest_storage_uri", "string").nullable(),
+      manifest_file_hash: column("manifest_file_hash", "string").nullable(),
+      asset_base_storage_uri: column(
+        "asset_base_storage_uri",
+        "string",
+      ).nullable(),
+      rollout_cohort_count: column("rollout_cohort_count", "integer").defaultTo(
+        1000,
+      ),
+      target_cohorts: column("target_cohorts", "json").nullable(),
+    }),
+    bundle_patches: table("bundle_patches", {
+      id: idColumn("id", "varchar(255)"),
+      bundle_id: column("bundle_id", "uuid"),
+      base_bundle_id: column("base_bundle_id", "uuid"),
+      base_file_hash: column("base_file_hash", "string"),
+      patch_file_hash: column("patch_file_hash", "string"),
+      patch_storage_uri: column("patch_storage_uri", "string"),
+      order_index: column("order_index", "integer").defaultTo(0),
+    }),
+  },
+  relations: {
+    bundle_patches: (builder) => ({
+      bundle: builder
+        .one("bundles", ["bundle_id", "id"])
+        .imply("patches")
+        .foreignKey({
+          name: "bundle_patches_bundle_id_fk",
+          onDelete: "CASCADE",
+        }),
+      baseBundle: builder
+        .one("bundles", ["base_bundle_id", "id"])
+        .imply("baseForPatches")
+        .foreignKey({
+          name: "bundle_patches_base_bundle_id_fk",
+          onDelete: "CASCADE",
+        }),
+    }),
+  },
+});

package/src/storageAccess.spec.ts

@@ -0,0 +1,57 @@
+import type { RuntimeStoragePlugin } from "@hot-updater/plugin-core";
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+import { createStorageAccess } from "./storageAccess";
+
+describe("createStorageAccess", () => {
+  afterEach(() => {
+    vi.unstubAllGlobals();
+  });
+
+  it("reads text through a matching runtime storage plugin before direct HTTP fetch", async () => {
+    const readText = vi.fn(async () => "manifest text");
+    const storagePlugin: RuntimeStoragePlugin = {
+      name: "httpStorage",
+      supportedProtocol: "http",
+      profiles: {
+        runtime: {
+          readText,
+          async getDownloadUrl(storageUri) {
+            return { fileUrl: storageUri };
+          },
+        },
+      },
+    };
+    const fetchMock = vi.fn<typeof fetch>(async () => {
+      return new Response("should not be used", { status: 500 });
+    });
+    vi.stubGlobal("fetch", fetchMock);
+
+    const { readStorageText } = createStorageAccess([storagePlugin]);
+
+    await expect(
+      readStorageText("http://assets.example.com/manifest.json"),
+    ).resolves.toBe("manifest text");
+    expect(readText).toHaveBeenCalledWith(
+      "http://assets.example.com/manifest.json",
+      undefined,
+    );
+    expect(fetchMock).not.toHaveBeenCalled();
+  });
+
+  it("reads direct HTTP storage text when no storage plugin owns the protocol", async () => {
+    const fetchMock = vi.fn<typeof fetch>(async () => {
+      return new Response("manifest text", { status: 200 });
+    });
+    vi.stubGlobal("fetch", fetchMock);
+
+    const { readStorageText } = createStorageAccess([]);
+
+    await expect(
+      readStorageText("https://assets.example.com/manifest.json"),
+    ).resolves.toBe("manifest text");
+    expect(fetchMock).toHaveBeenCalledWith(
+      "https://assets.example.com/manifest.json",
+    );
+  });
+});

package/src/storageAccess.ts

@@ -0,0 +1,90 @@
+import type {
+  HotUpdaterContext,
+  RuntimeStoragePlugin,
+} from "@hot-updater/plugin-core";
+
+const assertRemoteDownloadUrl = (fileUrl: string) => {
+  try {
+    const protocol = new URL(fileUrl).protocol.replace(":", "");
+    if (protocol === "http" || protocol === "https") {
+      return fileUrl;
+    }
+  } catch {
+    // Fall through to the runtime-specific error below.
+  }
+
+  throw new Error(
+    "Storage plugin returned a local file path; runtime update checks require an HTTP(S) download URL.",
+  );
+};
+
+const getStorageProtocol = (storageUri: string) =>
+  new URL(storageUri).protocol.replace(":", "");
+
+const isRemoteUrlProtocol = (protocol: string) =>
+  protocol === "http" || protocol === "https";
+
+export const createStorageAccess = <TContext>(
+  storagePlugins: RuntimeStoragePlugin<TContext>[],
+) => {
+  const findStoragePlugin = (protocol: string) => {
+    return storagePlugins.find((item) => item.supportedProtocol === protocol);
+  };
+
+  const resolveFileUrl = async (
+    storageUri: string | null,
+    context?: HotUpdaterContext<TContext>,
+  ): Promise<string | null> => {
+    if (!storageUri) {
+      return null;
+    }
+
+    const protocol = getStorageProtocol(storageUri);
+    const plugin = findStoragePlugin(protocol);
+    if (plugin) {
+      const downloadTarget = await plugin.profiles.runtime.getDownloadUrl(
+        storageUri,
+        context,
+      );
+      const { fileUrl } = downloadTarget;
+      if (!fileUrl) {
+        throw new Error("Storage plugin returned empty fileUrl");
+      }
+
+      return assertRemoteDownloadUrl(fileUrl);
+    }
+
+    if (isRemoteUrlProtocol(protocol)) {
+      return storageUri;
+    }
+
+    throw new Error(`No storage plugin for protocol: ${protocol}`);
+  };
+
+  const readStorageText = async (
+    storageUri: string,
+    context?: HotUpdaterContext<TContext>,
+  ): Promise<string | null> => {
+    const protocol = getStorageProtocol(storageUri);
+    const plugin = findStoragePlugin(protocol);
+    if (plugin) {
+      return plugin.profiles.runtime.readText(storageUri, context);
+    }
+
+    if (isRemoteUrlProtocol(protocol)) {
+      const response = await fetch(storageUri);
+      if (!response.ok) {
+        return null;
+      }
+
+      return response.text();
+    }
+
+    throw new Error(`No storage plugin for protocol: ${protocol}`);
+  };
+
+  return {
+    readStorageText,
+    resolveFileUrl,
+  };
+};