@hot-updater/server 0.36.7 → 1.0.0-rc.0

package/src/schema/v1_0_0.ts

@@ -0,0 +1,465 @@
+import {
+  bool,
+  check,
+  column,
+  foreignKey,
+  float,
+  idColumn,
+  index,
+  integer,
+  json,
+  largeString,
+  relation,
+  schema,
+  stringColumn,
+  table,
+  uniqueIndex,
+  uuid,
+  varchar,
+} from "./dsl";
+import { createSettingsTable } from "./settings";
+import { HOT_UPDATER_SETTINGS_TABLE } from "./types";
+
+const channelIdentityCollations = {
+  mysql: "utf8mb4_bin",
+  mssql: "Latin1_General_100_BIN2_SC",
+  sqlite: "binary",
+} as const;
+
+const catalogKeyCollations = {
+  mysql: "ascii_bin",
+  mssql: "Latin1_General_100_BIN2",
+  sqlite: "binary",
+} as const;
+
+export const channelsV100 = table(
+  "channels",
+  {
+    id: idColumn("id", varchar(255)).collate(channelIdentityCollations),
+    name: column("name", varchar(255)).collate(channelIdentityCollations),
+  },
+  {
+    indexes: [uniqueIndex("channels_name_key", ["name"])],
+    checks: [
+      check({
+        name: "channels_id_length_check",
+        expression: "char_length(id) between 1 and 255",
+        providerExpressions: {
+          mssql:
+            "len(id collate Latin1_General_100_BIN2_SC + N'#') - 1 between 1 and 255",
+          sqlite: "length(id) between 1 and 255",
+        },
+        sqliteInline: true,
+      }),
+      check({
+        name: "channels_name_length_check",
+        expression: "char_length(name) between 1 and 255",
+        providerExpressions: {
+          mssql:
+            "len(name collate Latin1_General_100_BIN2_SC + N'#') - 1 between 1 and 255",
+          sqlite: "length(name) between 1 and 255",
+        },
+        sqliteInline: true,
+      }),
+    ],
+  },
+);
+
+export const bundlePatchesV100 = table(
+  "bundle_patches",
+  {
+    id: idColumn("id", varchar(255)),
+    bundle_id: uuid("bundle_id"),
+    base_bundle_id: uuid("base_bundle_id"),
+    base_file_hash: column("base_file_hash", "string"),
+    patch_file_hash: column("patch_file_hash", "string"),
+    patch_storage_uri: column("patch_storage_uri", "string"),
+    byte_size: float("byte_size"),
+    order_index: integer("order_index").defaultTo(0),
+  },
+  {
+    indexes: [
+      index("bundle_patches_bundle_id_idx", ["bundle_id"]),
+      index("bundle_patches_base_bundle_id_idx", ["base_bundle_id"]),
+    ],
+    foreignKeys: [
+      foreignKey("bundle_patches_bundle_id_fk", ["bundle_id"], "bundles", [
+        "id",
+      ]),
+      foreignKey(
+        "bundle_patches_base_bundle_id_fk",
+        ["base_bundle_id"],
+        "bundles",
+        ["id"],
+      ),
+    ],
+    relations: [
+      relation({
+        name: "bundle",
+        fieldName: "patches",
+        targetFieldName: "bundle",
+        relationName: "bundle_patches_bundles_patches",
+        columns: ["bundle_id"],
+        referencedTable: "bundles",
+        referencedColumns: ["id"],
+      }),
+      relation({
+        name: "baseBundle",
+        fieldName: "baseForPatches",
+        targetFieldName: "baseBundle",
+        relationName: "bundle_patches_bundles_baseForPatches",
+        columns: ["base_bundle_id"],
+        referencedTable: "bundles",
+        referencedColumns: ["id"],
+      }),
+    ],
+    checks: [
+      check({
+        name: "bundle_patches_byte_size_check",
+        expression: "byte_size >= 0 and byte_size <= 9007199254740991",
+        sqliteInline: true,
+      }),
+    ],
+  },
+);
+
+export const apiKeysV100 = table(
+  "api_keys",
+  {
+    id: idColumn("id", varchar(255)),
+    hash: stringColumn("hash"),
+    name: stringColumn("name"),
+    prefix: stringColumn("prefix"),
+    role: stringColumn("role"),
+    created_at_ms: float("created_at_ms"),
+    revoked_at_ms: float("revoked_at_ms").nullable(),
+  },
+  {
+    indexes: [
+      uniqueIndex("api_keys_hash_key", ["hash"]),
+      index("api_keys_created_at_idx", ["created_at_ms", "id"]),
+    ],
+    checks: [
+      check({
+        name: "api_keys_role_check",
+        expression: "role = 'client'",
+        sqliteInline: true,
+      }),
+      check({
+        name: "api_keys_created_at_check",
+        expression: "created_at_ms >= 0",
+        sqliteInline: true,
+      }),
+      check({
+        name: "api_keys_revoked_at_check",
+        expression: "revoked_at_ms is null or revoked_at_ms >= 0",
+        sqliteInline: true,
+      }),
+    ],
+  },
+);
+
+export const bundlesV100 = table(
+  "bundles",
+  {
+    id: idColumn("id", "uuid"),
+    platform: stringColumn("platform"),
+    file_hash: stringColumn("file_hash"),
+    git_commit_hash: stringColumn("git_commit_hash").nullable(),
+    storage_uri: stringColumn("storage_uri"),
+    archive_byte_size: float("archive_byte_size"),
+    metadata: json("metadata").defaultTo({}),
+    manifest_storage_uri: stringColumn("manifest_storage_uri").nullable(),
+    manifest_file_hash: stringColumn("manifest_file_hash").nullable(),
+    asset_base_storage_uri: stringColumn("asset_base_storage_uri").nullable(),
+  },
+  {
+    indexes: [index("bundles_platform_idx", ["platform"], ["mongodb"])],
+    checks: [
+      check({
+        name: "bundles_archive_byte_size_check",
+        expression:
+          "archive_byte_size >= 0 and archive_byte_size <= 9007199254740991",
+        sqliteInline: true,
+      }),
+    ],
+  },
+);
+
+export const releasesV100 = table(
+  "releases",
+  {
+    id: idColumn("id", "uuid"),
+    revision: integer("revision"),
+    scope_key: column("scope_key", varchar(2048)).collate(catalogKeyCollations),
+    channel_id: column("channel_id", varchar(255)).collate(
+      channelIdentityCollations,
+    ),
+    platform: stringColumn("platform"),
+    kind: stringColumn("kind"),
+    bundle_id: column("bundle_id", "uuid").nullable(),
+    strategy: stringColumn("strategy"),
+    target_app_version: stringColumn("target_app_version").nullable(),
+    fingerprint_hash: stringColumn("fingerprint_hash").nullable(),
+    enabled: bool("enabled"),
+    should_force_update: bool("should_force_update"),
+    message: stringColumn("message").nullable(),
+    rollout_cohort_count: integer("rollout_cohort_count").defaultTo(1000),
+    target_cohorts: json("target_cohorts").defaultTo([]),
+    operation: stringColumn("operation"),
+    source_release_id: column("source_release_id", "uuid").nullable(),
+    created_at_ms: float("created_at_ms"),
+    updated_at_ms: float("updated_at_ms"),
+  },
+  {
+    indexes: [
+      index("releases_scope_order_idx", ["scope_key", "id"]),
+      index("releases_channel_platform_order_idx", [
+        "channel_id",
+        "platform",
+        "id",
+      ]),
+      index("releases_bundle_id_idx", ["bundle_id"]),
+      index("releases_fingerprint_hash_idx", ["fingerprint_hash"]),
+      index("releases_enabled_idx", ["enabled"]),
+    ],
+    checks: [
+      check({
+        name: "releases_revision_check",
+        expression: "revision >= 1",
+        sqliteInline: true,
+      }),
+      check({
+        name: "releases_kind_bundle_check",
+        expression:
+          "(kind = 'BUNDLE' and bundle_id is not null) or (kind = 'EMBEDDED' and bundle_id is null)",
+        sqliteInline: true,
+      }),
+      check({
+        name: "releases_strategy_target_check",
+        expression:
+          "(strategy = 'APP_VERSION' and target_app_version is not null and fingerprint_hash is null) or (strategy = 'FINGERPRINT' and target_app_version is null and fingerprint_hash is not null)",
+        sqliteInline: true,
+      }),
+      check({
+        name: "releases_rollout_cohort_count_check",
+        expression:
+          "rollout_cohort_count >= 0 and rollout_cohort_count <= 1000",
+        sqliteInline: true,
+      }),
+      check({
+        name: "releases_operation_check",
+        expression: "operation in ('DEPLOY', 'PROMOTE', 'ROLLBACK')",
+        sqliteInline: true,
+      }),
+    ],
+    foreignKeys: [
+      foreignKey("releases_channel_id_fk", ["channel_id"], "channels", ["id"], {
+        onDelete: "restrict",
+      }),
+      foreignKey("releases_bundle_id_fk", ["bundle_id"], "bundles", ["id"], {
+        onDelete: "restrict",
+      }),
+      foreignKey(
+        "releases_source_release_id_fk",
+        ["source_release_id"],
+        "releases",
+        ["id"],
+        { onDelete: "set null" },
+      ),
+    ],
+    relations: [
+      relation({
+        name: "channelRecord",
+        fieldName: "releases",
+        targetFieldName: "channelRecord",
+        relationName: "releases_channels",
+        columns: ["channel_id"],
+        referencedTable: "channels",
+        referencedColumns: ["id"],
+      }),
+      relation({
+        name: "bundle",
+        fieldName: "releases",
+        targetFieldName: "bundle",
+        relationName: "releases_bundles",
+        columns: ["bundle_id"],
+        referencedTable: "bundles",
+        referencedColumns: ["id"],
+      }),
+      relation({
+        name: "sourceRelease",
+        fieldName: "derivedReleases",
+        targetFieldName: "sourceRelease",
+        relationName: "releases_source_release",
+        columns: ["source_release_id"],
+        referencedTable: "releases",
+        referencedColumns: ["id"],
+      }),
+    ],
+  },
+);
+
+export const releaseCatalogsV100 = table(
+  "release_catalogs",
+  {
+    scope_key: idColumn("scope_key", varchar(2048)).collate(
+      catalogKeyCollations,
+    ),
+    catalog_id: column("catalog_id", varchar(255)),
+    strategy: stringColumn("strategy"),
+    channel_id: column("channel_id", varchar(255)).collate(
+      channelIdentityCollations,
+    ),
+    channel_key: column("channel_key", varchar(1400)).collate(
+      catalogKeyCollations,
+    ),
+    platform: stringColumn("platform"),
+    fingerprint_hash: stringColumn("fingerprint_hash").nullable(),
+    generation: float("generation"),
+    payload: largeString("payload"),
+    catalog_hash: column("catalog_hash", varchar(71)),
+    byte_size: integer("byte_size"),
+    is_tombstone: bool("is_tombstone"),
+    updated_at_ms: float("updated_at_ms"),
+  },
+  {
+    indexes: [index("release_catalogs_channel_idx", ["channel_id"])],
+    checks: [
+      check({
+        name: "release_catalogs_strategy_target_check",
+        expression:
+          "(strategy = 'APP_VERSION' and fingerprint_hash is null) or (strategy = 'FINGERPRINT' and fingerprint_hash is not null)",
+        sqliteInline: true,
+      }),
+      check({
+        name: "release_catalogs_generation_check",
+        expression: "generation >= 1 and generation <= 9007199254740991",
+        sqliteInline: true,
+      }),
+      check({
+        name: "release_catalogs_byte_size_check",
+        expression: "byte_size >= 0 and byte_size <= 262144",
+        sqliteInline: true,
+      }),
+    ],
+    foreignKeys: [
+      foreignKey(
+        "release_catalogs_channel_id_fk",
+        ["channel_id"],
+        "channels",
+        ["id"],
+        { onDelete: "restrict" },
+      ),
+    ],
+    relations: [
+      relation({
+        name: "channelRecord",
+        fieldName: "releaseCatalogs",
+        targetFieldName: "channelRecord",
+        relationName: "release_catalogs_channels",
+        columns: ["channel_id"],
+        referencedTable: "channels",
+        referencedColumns: ["id"],
+      }),
+    ],
+  },
+);
+
+export const bundleEventsV100 = table(
+  "bundle_events",
+  {
+    id: idColumn("id", "uuid"),
+    type: stringColumn("type"),
+    install_id: stringColumn("install_id"),
+    user_id: stringColumn("user_id").nullable(),
+    username: stringColumn("username").nullable(),
+    from_release_id: uuid("from_release_id").nullable(),
+    from_bundle_id: uuid("from_bundle_id").nullable(),
+    to_release_id: uuid("to_release_id").nullable(),
+    to_bundle_id: uuid("to_bundle_id"),
+    platform: stringColumn("platform"),
+    app_version: stringColumn("app_version"),
+    channel: stringColumn("channel"),
+    cohort: stringColumn("cohort"),
+    update_strategy: stringColumn("update_strategy").nullable(),
+    fingerprint_hash: stringColumn("fingerprint_hash").nullable(),
+    sdk_version: stringColumn("sdk_version").nullable(),
+    received_at_ms: float("received_at_ms"),
+  },
+  {
+    indexes: [
+      index("bundle_events_received_at_idx", ["received_at_ms", "id"]),
+      index("bundle_events_install_idx", [
+        "install_id",
+        "received_at_ms",
+        "id",
+      ]),
+      index("bundle_events_user_id_idx", ["user_id", "received_at_ms", "id"]),
+      index("bundle_events_username_idx", ["username", "received_at_ms", "id"]),
+      index("bundle_events_to_bundle_idx", [
+        "type",
+        "to_bundle_id",
+        "received_at_ms",
+        "id",
+      ]),
+      index("bundle_events_from_bundle_idx", [
+        "type",
+        "from_bundle_id",
+        "received_at_ms",
+        "id",
+      ]),
+      index("bundle_events_to_release_idx", [
+        "type",
+        "to_release_id",
+        "received_at_ms",
+        "id",
+      ]),
+      index("bundle_events_from_release_idx", [
+        "type",
+        "from_release_id",
+        "received_at_ms",
+        "id",
+      ]),
+    ],
+    checks: [
+      check({
+        name: "bundle_events_type_check",
+        expression:
+          "type in ('UPDATE_APPLIED', 'RECOVERED', 'RELEASE_ADOPTED', 'UNCHANGED')",
+        sqliteInline: true,
+      }),
+      check({
+        name: "bundle_events_platform_check",
+        expression: "platform in ('ios', 'android')",
+        sqliteInline: true,
+      }),
+      check({
+        name: "bundle_events_shape_check",
+        expression:
+          "((type in ('UPDATE_APPLIED', 'RECOVERED', 'RELEASE_ADOPTED')) and from_bundle_id is not null and update_strategy is not null and update_strategy in ('fingerprint', 'appVersion')) or (type = 'UNCHANGED' and from_bundle_id is null and update_strategy is null)",
+        sqliteInline: true,
+      }),
+      check({
+        name: "bundle_events_received_at_check",
+        expression: "received_at_ms >= 0",
+        sqliteInline: true,
+      }),
+    ],
+  },
+);
+
+export const v1_0_0 = schema({
+  version: "1.0.0",
+  settingsTable: HOT_UPDATER_SETTINGS_TABLE,
+  tables: [
+    channelsV100,
+    bundlesV100,
+    bundlePatchesV100,
+    releasesV100,
+    releaseCatalogsV100,
+    bundleEventsV100,
+    apiKeysV100,
+    createSettingsTable("1.0.0"),
+  ],
+});

package/src/storageAccess.spec.ts

@@ -1,4 +1,7 @@
-import type { RuntimeStoragePlugin } from "@hot-updater/plugin-core";
+import {
+  createStorageDownloadPath,
+  createStoragePlugin,
+} from "@hot-updater/plugin-core";
 import { afterEach, describe, expect, it, vi } from "vitest";
 
 import { createStorageAccess } from "./storageAccess";
@@ -8,50 +11,142 @@ describe("createStorageAccess", () => {
     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 });
+  it("reads text through a matching storage implementation", async () => {
+    const get = vi.fn(
+      async (_storageUri: string) => new Response("manifest text"),
+    );
+    const storage = createStoragePlugin({
+      name: "r2Storage",
+      protocol: "r2",
+      get: async (input) => ({ response: await get(input.storageUri) }),
     });
-    vi.stubGlobal("fetch", fetchMock);
+    const { readStorageText } = createStorageAccess([storage]);
 
-    const { readStorageText } = createStorageAccess([storagePlugin]);
+    await expect(readStorageText("r2://assets/manifest.json")).resolves.toBe(
+      "manifest text",
+    );
+    expect(get).toHaveBeenCalledWith("r2://assets/manifest.json");
+  });
+
+  it("reads direct HTTP storage when no plugin owns the protocol", async () => {
+    const fetchMock = vi.fn<typeof fetch>(
+      async () => new Response("manifest text"),
+    );
+    vi.stubGlobal("fetch", fetchMock);
+    const { readStorageText } = createStorageAccess([]);
 
     await expect(
-      readStorageText("http://assets.example.com/manifest.json"),
+      readStorageText("https://assets.example.com/manifest.json"),
     ).resolves.toBe("manifest text");
-    expect(readText).toHaveBeenCalledWith(
-      "http://assets.example.com/manifest.json",
-      undefined,
+  });
+
+  it("uses an unowned HTTPS URI directly as the download URL", async () => {
+    const { resolveFileUrl } = createStorageAccess([]);
+    const storageUri = "https://assets.example.com/bundle.zip";
+
+    await expect(resolveFileUrl(storageUri)).resolves.toBe(storageUri);
+  });
+
+  it("lets a matching HTTPS storage own reads before direct fetch", async () => {
+    const fetchMock = vi.fn<typeof fetch>();
+    vi.stubGlobal("fetch", fetchMock);
+    const get = vi.fn(
+      async () => ({ response: new Response("owned manifest") }) as const,
     );
+    const storage = createStoragePlugin({
+      name: "standaloneStorage",
+      protocol: "https",
+      get,
+    });
+    const { readStorageText } = createStorageAccess([storage]);
+    const storageUri = "https://storage.example.com/manifest.json";
+
+    await expect(readStorageText(storageUri)).resolves.toBe("owned manifest");
+    expect(get).toHaveBeenCalledWith({ storageUri });
     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 });
+  it("lets a matching HTTPS storage resolve the download URL", async () => {
+    const getDownloadUrl = vi.fn(async () => ({
+      url: "https://cdn.example.com/bundle.zip",
+    }));
+    const storage = createStoragePlugin({
+      name: "standaloneStorage",
+      protocol: "https",
+      get: async () => ({ response: null }),
+      getDownloadUrl,
     });
-    vi.stubGlobal("fetch", fetchMock);
+    const { resolveFileUrl } = createStorageAccess([storage]);
+    const storageUri = "https://storage.example.com/bundle.zip";
 
-    const { readStorageText } = createStorageAccess([]);
+    await expect(resolveFileUrl(storageUri)).resolves.toBe(
+      "https://cdn.example.com/bundle.zip",
+    );
+    expect(getDownloadUrl).toHaveBeenCalledWith({ storageUri });
+  });
+
+  it("creates and serves a runtime-neutral delivery URL", async () => {
+    const storage = createStoragePlugin({
+      name: "r2Storage",
+      protocol: "r2",
+      get: vi.fn(
+        async () =>
+          ({
+            response: new Response("bundle", {
+              headers: { "content-type": "application/zip" },
+            }),
+          }) as const,
+      ),
+      getDownloadUrl: async ({ storageUri }) => ({
+        url: createStorageDownloadPath(storageUri, "test-signature"),
+      }),
+    });
+    const access = createStorageAccess([storage]);
 
+    const fileUrl = await access.resolveFileUrl("r2://bucket/bundle.zip");
+    expect(fileUrl).toMatch(/^\/storage\//);
+    const segments = fileUrl!.split("/");
+    const token = segments.at(-2)!;
+    const signature = segments.at(-1)!;
+    const response = await access.downloadStorageObject!(token, signature);
+    await expect(response?.text()).resolves.toBe("bundle");
     await expect(
-      readStorageText("https://assets.example.com/manifest.json"),
-    ).resolves.toBe("manifest text");
-    expect(fetchMock).toHaveBeenCalledWith(
-      "https://assets.example.com/manifest.json",
+      access.downloadStorageObject!(token, `${signature}tampered`),
+    ).resolves.toBeNull();
+  });
+
+  it("lets a CDN resolver bypass built-in server delivery", async () => {
+    const resolveUrl = vi.fn(async () => ({
+      url: "https://cdn.example.com/bundle.zip",
+    }));
+    const storage = createStoragePlugin({
+      name: "s3Storage",
+      protocol: "s3",
+      get: async () => ({ response: null }),
+      getDownloadUrl: resolveUrl,
+    });
+    const access = createStorageAccess([storage]);
+
+    await expect(access.resolveFileUrl("s3://bucket/bundle.zip")).resolves.toBe(
+      "https://cdn.example.com/bundle.zip",
+    );
+    expect(access.downloadStorageObject).toEqual(expect.any(Function));
+  });
+
+  it("rejects ambiguous storage protocol ownership", () => {
+    const first = createStoragePlugin({
+      name: "firstR2Storage",
+      protocol: "r2",
+      get: async () => ({ response: null }),
+    });
+    const second = createStoragePlugin({
+      name: "secondR2Storage",
+      protocol: "r2",
+      get: async () => ({ response: null }),
+    });
+
+    expect(() => createStorageAccess([first, second])).toThrow(
+      "Multiple storage plugins handle protocol: r2",
     );
   });
 });