@hot-updater/server 1.0.0-rc.2 → 1.0.0-rc.21

package/src/schema/v1_0_0.ts

@@ -1,529 +0,0 @@
-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"],
-      }),
-    ],
-  },
-);
-
-const insightsTextCollations = {
-  postgresql: '"C"',
-  mysql: "utf8mb4_0900_bin",
-} as const;
-const insightsProviders = [
-  "postgresql",
-  "mysql",
-  "sqlite",
-  "cockroachdb",
-  "mongodb",
-] as const;
-
-export const bundleEventsV100 = table(
-  "bundle_events",
-  {
-    id: idColumn("id", "uuid"),
-    type: column("type", varchar(32)),
-    install_id: column("install_id", varchar(255)).collate(
-      insightsTextCollations,
-    ),
-    user_id: column("user_id", varchar(255))
-      .collate(insightsTextCollations)
-      .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").collate(insightsTextCollations),
-    app_version: stringColumn("app_version"),
-    channel: stringColumn("channel").collate(insightsTextCollations),
-    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",
-        "type",
-        "received_at_ms",
-        "id",
-      ]),
-      index(
-        "bundle_events_from_bundle_idx",
-        [
-          "type",
-          "platform",
-          "channel",
-          "from_bundle_id",
-          "received_at_ms",
-          "id",
-        ],
-        insightsProviders,
-      ),
-      index(
-        "bundle_events_to_bundle_idx",
-        ["type", "platform", "channel", "to_bundle_id", "received_at_ms", "id"],
-        insightsProviders,
-      ),
-    ],
-    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 bundleInstallationsV100 = table(
-  "bundle_installations",
-  {
-    install_id: idColumn("install_id", varchar(255)).collate(
-      insightsTextCollations,
-    ),
-    id: uuid("id"),
-    user_id: column("user_id", varchar(255))
-      .collate(insightsTextCollations)
-      .nullable(),
-    username: stringColumn("username").nullable(),
-    to_bundle_id: uuid("to_bundle_id"),
-    type: column("type", varchar(32)),
-    platform: stringColumn("platform").collate(insightsTextCollations),
-    app_version: stringColumn("app_version"),
-    channel: stringColumn("channel").collate(insightsTextCollations),
-    cohort: stringColumn("cohort"),
-    received_at_ms: float("received_at_ms"),
-  },
-  {
-    indexes: [
-      index("bundle_installations_user_id_idx", ["user_id", "install_id"]),
-      index("bundle_installations_received_at_idx", ["received_at_ms"]),
-      index(
-        "bundle_installations_scope_idx",
-        ["platform", "channel", "received_at_ms"],
-        insightsProviders,
-      ),
-      index(
-        "bundle_installations_bundle_idx",
-        ["platform", "channel", "to_bundle_id", "received_at_ms"],
-        insightsProviders,
-      ),
-    ],
-    checks: [
-      check({
-        name: "bundle_installations_type_check",
-        expression:
-          "type in ('UPDATE_APPLIED', 'RECOVERED', 'RELEASE_ADOPTED', 'UNCHANGED')",
-        sqliteInline: true,
-      }),
-      check({
-        name: "bundle_installations_platform_check",
-        expression: "platform in ('ios', 'android')",
-        sqliteInline: true,
-      }),
-      check({
-        name: "bundle_installations_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,
-    bundleInstallationsV100,
-    apiKeysV100,
-    createSettingsTable("1.0.0"),
-  ],
-});

package/src/storageAccess.spec.ts

@@ -1,152 +0,0 @@
-import {
-  createStorageDownloadPath,
-  createStoragePlugin,
-} 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 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) }),
-    });
-    const { readStorageText } = createStorageAccess([storage]);
-
-    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("https://assets.example.com/manifest.json"),
-    ).resolves.toBe("manifest text");
-  });
-
-  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("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,
-    });
-    const { resolveFileUrl } = createStorageAccess([storage]);
-    const storageUri = "https://storage.example.com/bundle.zip";
-
-    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(
-      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",
-    );
-  });
-});