@hot-updater/server 0.33.2 → 0.35.0

package/src/runtime.spec.ts

@@ -1,3 +1,5 @@
+import { readFile } from "fs/promises";
+
 import type { Bundle } from "@hot-updater/core";
 import { NIL_UUID } from "@hot-updater/core";
 import type {
@@ -9,7 +11,9 @@ import type {
 import { createDatabasePlugin } from "@hot-updater/plugin-core";
 import { describe, expect, expectTypeOf, it, vi } from "vitest";
 
-import { createHotUpdater } from "./runtime";
+import type { DatabaseAdapterCapabilities, Migrator } from "./db/types";
+import { createHotUpdater } from "./index";
+import type { HandlerAPI, HandlerOptions, HandlerRoutes } from "./index";
 import { HOT_UPDATER_SERVER_VERSION } from "./version";
 
 const bundle: Bundle = {
@@ -46,7 +50,114 @@ const createRuntimeStorage = (
   },
 });
 
+const createSchemaManagedDatabase = (
+  adapterName: string,
+  version: string | undefined,
+): DatabasePlugin<TestContext> & DatabaseAdapterCapabilities => ({
+  name: `${adapterName}Database`,
+  adapterName,
+  createMigrator: () =>
+    ({
+      async getVersion() {
+        return version;
+      },
+      async getNameVariants() {
+        return {};
+      },
+      async next() {
+        return undefined;
+      },
+      async previous() {
+        return undefined;
+      },
+      async up() {
+        throw new Error("not implemented");
+      },
+      async down() {
+        throw new Error("not implemented");
+      },
+      async migrateTo() {
+        throw new Error("not implemented");
+      },
+      async migrateToLatest() {
+        throw new Error("not implemented");
+      },
+      async migrate() {},
+    }) as Migrator,
+  async appendBundle() {},
+  async commitBundle() {},
+  async deleteBundle() {},
+  async getBundleById() {
+    throw new Error("runtime database should not be queried");
+  },
+  async getBundles() {
+    throw new Error("runtime database should not be queried");
+  },
+  async getChannels() {
+    throw new Error("runtime database should not be queried");
+  },
+  async updateBundle() {},
+});
+
 describe("runtime createHotUpdater", () => {
+  it("publishes db tooling subpath and removes the runtime subpath", async () => {
+    const packageJson = JSON.parse(
+      await readFile(new URL("../package.json", import.meta.url), "utf-8"),
+    ) as {
+      exports: Record<string, unknown>;
+    };
+
+    expect(packageJson.exports["./db"]).toBeDefined();
+    expect(packageJson.exports["./runtime"]).toBeUndefined();
+  });
+
+  it("exports runtime-safe handler types from the root entry", () => {
+    expectTypeOf<HandlerAPI>().toHaveProperty("getBundles");
+    expectTypeOf<HandlerOptions>().toHaveProperty("routes");
+    expectTypeOf<HandlerRoutes>().toEqualTypeOf<{
+      updateCheck: boolean;
+      bundles: boolean;
+    }>();
+  });
+
+  it("exports the root runtime API without database capabilities", () => {
+    const database: DatabasePlugin<TestContext> = {
+      name: "testDatabase",
+      async appendBundle() {},
+      async commitBundle() {},
+      async deleteBundle() {},
+      async getBundleById() {
+        return null;
+      },
+      async getBundles() {
+        return {
+          data: [],
+          pagination: {
+            currentPage: 1,
+            hasNextPage: false,
+            hasPreviousPage: false,
+            total: 0,
+            totalPages: 0,
+          },
+        };
+      },
+      async getChannels() {
+        return [];
+      },
+      async updateBundle() {},
+    };
+
+    const hotUpdater = createHotUpdater({ database });
+
+    expect(hotUpdater.basePath).toBe("/api");
+    expect(hotUpdater.adapterName).toBe("testDatabase");
+    expect(hotUpdater.handler).toEqual(expect.any(Function));
+    expect("createMigrator" in hotUpdater).toBe(false);
+    expect("generateSchema" in hotUpdater).toBe(false);
+    expectTypeOf(hotUpdater).not.toHaveProperty("createMigrator");
+    expectTypeOf(hotUpdater).not.toHaveProperty("generateSchema");
+  });
+
   it("requires storages to implement the runtime profile", () => {
     const database: DatabasePlugin<TestContext> = {
       name: "testDatabase",
@@ -98,6 +209,26 @@ describe("runtime createHotUpdater", () => {
     );
   });
 
+  it("rejects runtime access when a Kysely schema is not initialized", async () => {
+    const hotUpdater = createHotUpdater({
+      database: createSchemaManagedDatabase("kysely", undefined),
+    });
+
+    await expect(hotUpdater.getBundles({ limit: 10 })).rejects.toThrow(
+      "Hot Updater database schema is not initialized for kysely.",
+    );
+  });
+
+  it("rejects runtime access when a MongoDB schema is stale", async () => {
+    const hotUpdater = createHotUpdater({
+      database: createSchemaManagedDatabase("mongodb", "0.21.0"),
+    });
+
+    await expect(hotUpdater.getChannels()).rejects.toThrow(
+      "Hot Updater database schema version 0.21.0 is not supported by mongodb.",
+    );
+  });
+
   it("resolves storage URLs with handler context when database fast-path is used", async () => {
     const request = new Request(
       "https://updates.example.com/api/check-update/app-version/ios/1.0.0/production/" +

package/src/schema/dsl-all-versions.spec.ts

@@ -0,0 +1,26 @@
+import { describe, expect, it } from "vitest";
+
+import { createSettingsTable } from "./settings";
+import { bundlesV021, v0_21_0 } from "./v0_21_0";
+import { bundlesV029, v0_29_0 } from "./v0_29_0";
+import { bundlesV031, v0_31_0 } from "./v0_31_0";
+
+describe("versioned schema DSL", () => {
+  it("uses the local functional DSL for every versioned schema table", () => {
+    expect(v0_21_0.dsl).toBe("schema");
+    expect(v0_29_0.dsl).toBe("schema");
+    expect(v0_31_0.dsl).toBe("schema");
+
+    expect(bundlesV021.dsl).toBe("table");
+    expect(bundlesV029.dsl).toBe("table");
+    expect(bundlesV031.dsl).toBe("table");
+    expect(createSettingsTable("0.31.0").dsl).toBe("table");
+
+    for (const schema of [v0_21_0, v0_29_0, v0_31_0]) {
+      expect(Object.keys(schema)).not.toContain("dsl");
+      for (const table of schema.tables) {
+        expect(Object.keys(table)).not.toContain("dsl");
+      }
+    }
+  });
+});

package/src/schema/dsl.ts

@@ -0,0 +1,148 @@
+import type {
+  HotUpdaterColumnSchema,
+  HotUpdaterColumnType,
+  HotUpdaterCheckSchema,
+  HotUpdaterDefault,
+  HotUpdaterForeignKeySchema,
+  HotUpdaterIndexSchema,
+  HotUpdaterRelationSchema,
+  HotUpdaterTableSchema,
+  HotUpdaterVersionedSchema,
+} from "./types";
+
+type DefaultValue = boolean | number | string | Record<string, unknown>;
+
+export type HotUpdaterColumnDsl = {
+  readonly dsl: "column";
+  readonly ormName: string;
+  readonly type: HotUpdaterColumnType;
+  readonly default?: HotUpdaterDefault;
+  readonly nullableValue?: true;
+  readonly primaryKeyValue?: true;
+  readonly nullable: () => HotUpdaterColumnDsl;
+  readonly primaryKey: () => HotUpdaterColumnDsl;
+  readonly defaultTo: (value: DefaultValue) => HotUpdaterColumnDsl;
+};
+
+export type HotUpdaterTableDsl = HotUpdaterTableSchema & {
+  readonly dsl: "table";
+};
+
+const withDsl = <Value extends object, Dsl extends string>(
+  value: Value,
+  dsl: Dsl,
+): Value & { readonly dsl: Dsl } =>
+  Object.defineProperty(value, "dsl", {
+    enumerable: false,
+    value: dsl,
+  }) as Value & { readonly dsl: Dsl };
+
+const defaultValue = (value: DefaultValue): HotUpdaterDefault =>
+  typeof value === "object"
+    ? { type: "json", value }
+    : { type: "literal", value };
+
+const columnSchema = (column: HotUpdaterColumnDsl): HotUpdaterColumnSchema => ({
+  ormName: column.ormName,
+  type: column.type,
+  ...(column.nullableValue ? { nullable: true } : {}),
+  ...(column.primaryKeyValue ? { primaryKey: true } : {}),
+  ...(column.default ? { default: column.default } : {}),
+});
+
+type ColumnState = HotUpdaterColumnSchema & {
+  readonly nullableValue?: boolean;
+  readonly primaryKeyValue?: boolean;
+};
+
+const createColumn = (state: ColumnState): HotUpdaterColumnDsl => ({
+  dsl: "column",
+  ormName: state.ormName,
+  type: state.type,
+  ...(state.nullableValue ? { nullableValue: true } : {}),
+  ...(state.primaryKeyValue ? { primaryKeyValue: true } : {}),
+  ...(state.default ? { default: state.default } : {}),
+  nullable: () => createColumn({ ...state, nullableValue: true }),
+  primaryKey: () => createColumn({ ...state, primaryKeyValue: true }),
+  defaultTo: (value) =>
+    createColumn({ ...state, default: defaultValue(value) }),
+});
+
+export const varchar = <Length extends number>(
+  length: Length,
+): `varchar(${Length})` => `varchar(${length})` as `varchar(${Length})`;
+
+export const column = (
+  ormName: string,
+  type: HotUpdaterColumnType,
+): HotUpdaterColumnDsl => createColumn({ ormName, type });
+
+export const idColumn = (
+  ormName: string,
+  type: HotUpdaterColumnType,
+): HotUpdaterColumnDsl => column(ormName, type).primaryKey();
+
+export const uuid = (ormName: string): HotUpdaterColumnDsl =>
+  column(ormName, "uuid");
+
+export const integer = (ormName: string): HotUpdaterColumnDsl =>
+  column(ormName, "integer");
+
+export const bool = (ormName: string): HotUpdaterColumnDsl =>
+  column(ormName, "bool");
+
+export const json = (ormName: string): HotUpdaterColumnDsl =>
+  column(ormName, "json");
+
+export const stringColumn = (ormName: string): HotUpdaterColumnDsl =>
+  column(ormName, "string");
+
+export const index = (
+  name: string,
+  columns: readonly string[],
+  providers?: HotUpdaterIndexSchema["providers"],
+): HotUpdaterIndexSchema => ({
+  name,
+  columns,
+  ...(providers ? { providers } : {}),
+});
+
+export const foreignKey = (
+  name: string,
+  columns: readonly string[],
+  referencedTable: string,
+  referencedColumns: readonly string[],
+): HotUpdaterForeignKeySchema => ({
+  name,
+  columns,
+  referencedTable,
+  referencedColumns,
+  onUpdate: "restrict",
+  onDelete: "cascade",
+});
+
+export const check = (config: HotUpdaterCheckSchema): HotUpdaterCheckSchema =>
+  config;
+
+export const relation = (
+  config: HotUpdaterRelationSchema,
+): HotUpdaterRelationSchema => config;
+
+export const table = (
+  ormName: string,
+  columns: Record<string, HotUpdaterColumnDsl>,
+  extras: Omit<HotUpdaterTableSchema, "columns" | "ormName"> = {},
+): HotUpdaterTableDsl =>
+  withDsl(
+    {
+      ormName,
+      columns: Object.values(columns).map(columnSchema),
+      ...extras,
+    },
+    "table",
+  );
+
+export const schema = (
+  value: HotUpdaterVersionedSchema,
+): HotUpdaterVersionedSchema & { readonly dsl: "schema" } =>
+  withDsl({ ...value }, "schema");

package/src/schema/index.ts

@@ -0,0 +1,16 @@
+import type { HotUpdaterVersionedSchema } from "./types";
+import { v0_21_0 } from "./v0_21_0";
+import { v0_29_0 } from "./v0_29_0";
+import { v0_31_0 } from "./v0_31_0";
+
+export * from "./settings";
+export * from "./types";
+export * from "./v0_21_0";
+export * from "./v0_29_0";
+export * from "./v0_31_0";
+
+export const hotUpdaterSchemaVersions: readonly HotUpdaterVersionedSchema[] = [
+  v0_21_0,
+  v0_29_0,
+  v0_31_0,
+];

package/src/schema/settings.ts

@@ -0,0 +1,15 @@
+import { idColumn, stringColumn, table, varchar } from "./dsl";
+import {
+  HOT_UPDATER_SETTINGS_TABLE,
+  type HotUpdaterSchemaVersion,
+} from "./types";
+
+export const createSettingsTable = (version: HotUpdaterSchemaVersion) =>
+  table(
+    HOT_UPDATER_SETTINGS_TABLE,
+    {
+      key: idColumn("key", varchar(255)),
+      value: stringColumn("value").defaultTo(version),
+    },
+    { internal: true },
+  );

package/src/schema/types.ts

@@ -0,0 +1,73 @@
+import type { ORMProvider } from "../db/types";
+
+export const HOT_UPDATER_SCHEMA_VERSION = "0.31.0";
+export const HOT_UPDATER_SETTINGS_TABLE = "private_hot_updater_settings";
+
+export type HotUpdaterColumnType =
+  | "bool"
+  | "integer"
+  | "json"
+  | "string"
+  | "uuid"
+  | `varchar(${number})`;
+
+export type HotUpdaterDefault =
+  | { readonly type: "literal"; readonly value: boolean | number | string }
+  | { readonly type: "json"; readonly value: unknown };
+
+export interface HotUpdaterColumnSchema {
+  readonly ormName: string;
+  readonly type: HotUpdaterColumnType;
+  readonly nullable?: boolean;
+  readonly primaryKey?: boolean;
+  readonly default?: HotUpdaterDefault;
+}
+
+export interface HotUpdaterIndexSchema {
+  readonly name: string;
+  readonly columns: readonly string[];
+  readonly providers?: readonly ORMProvider[];
+}
+
+export interface HotUpdaterCheckSchema {
+  readonly name: string;
+  readonly expression: string;
+  readonly sqliteInline?: boolean;
+}
+
+export interface HotUpdaterForeignKeySchema {
+  readonly name: string;
+  readonly columns: readonly string[];
+  readonly referencedTable: string;
+  readonly referencedColumns: readonly string[];
+  readonly onUpdate: "restrict";
+  readonly onDelete: "cascade";
+}
+
+export interface HotUpdaterRelationSchema {
+  readonly name: string;
+  readonly fieldName: string;
+  readonly targetFieldName: string;
+  readonly relationName: string;
+  readonly columns: readonly string[];
+  readonly referencedTable: string;
+  readonly referencedColumns: readonly string[];
+}
+
+export interface HotUpdaterTableSchema {
+  readonly ormName: string;
+  readonly columns: readonly HotUpdaterColumnSchema[];
+  readonly indexes?: readonly HotUpdaterIndexSchema[];
+  readonly checks?: readonly HotUpdaterCheckSchema[];
+  readonly foreignKeys?: readonly HotUpdaterForeignKeySchema[];
+  readonly relations?: readonly HotUpdaterRelationSchema[];
+  readonly internal?: boolean;
+}
+
+export interface HotUpdaterVersionedSchema {
+  readonly version: HotUpdaterSchemaVersion;
+  readonly settingsTable: string;
+  readonly tables: readonly HotUpdaterTableSchema[];
+}
+
+export type HotUpdaterSchemaVersion = "0.21.0" | "0.29.0" | "0.31.0";

package/src/schema/v0_21_0.ts

@@ -1,22 +1,52 @@
-import { column, idColumn, schema, table } from "fumadb/schema";
+import {
+  bool,
+  check,
+  idColumn,
+  index,
+  json,
+  schema,
+  stringColumn,
+  table,
+} from "./dsl";
+import { createSettingsTable } from "./settings";
+import { HOT_UPDATER_SETTINGS_TABLE } from "./types";
+
+export const bundlesV021 = table(
+  "bundles",
+  {
+    id: idColumn("id", "uuid"),
+    platform: stringColumn("platform"),
+    should_force_update: bool("should_force_update"),
+    enabled: bool("enabled"),
+    file_hash: stringColumn("file_hash"),
+    git_commit_hash: stringColumn("git_commit_hash").nullable(),
+    message: stringColumn("message").nullable(),
+    channel: stringColumn("channel").defaultTo("production"),
+    storage_uri: stringColumn("storage_uri"),
+    target_app_version: stringColumn("target_app_version").nullable(),
+    fingerprint_hash: stringColumn("fingerprint_hash").nullable(),
+    metadata: json("metadata").defaultTo({}),
+  },
+  {
+    indexes: [
+      index("bundles_target_app_version_idx", ["target_app_version"]),
+      index("bundles_fingerprint_hash_idx", ["fingerprint_hash"]),
+      index("bundles_channel_idx", ["channel"]),
+      index("bundles_platform_idx", ["platform"], ["mongodb"]),
+    ],
+    checks: [
+      check({
+        name: "check_version_or_fingerprint",
+        expression:
+          "(target_app_version is not null) or (fingerprint_hash is not null)",
+        sqliteInline: true,
+      }),
+    ],
+  },
+);
 
 export const v0_21_0 = schema({
   version: "0.21.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"),
-    }),
-  },
-  relations: {},
+  settingsTable: HOT_UPDATER_SETTINGS_TABLE,
+  tables: [bundlesV021, createSettingsTable("0.21.0")],
 });

package/src/schema/v0_29_0.ts

@@ -1,26 +1,62 @@
-import { column, idColumn, schema, table } from "fumadb/schema";
+import {
+  bool,
+  check,
+  idColumn,
+  index,
+  integer,
+  json,
+  schema,
+  stringColumn,
+  table,
+} from "./dsl";
+import { createSettingsTable } from "./settings";
+import { HOT_UPDATER_SETTINGS_TABLE } from "./types";
+
+export const bundlesV029 = table(
+  "bundles",
+  {
+    id: idColumn("id", "uuid"),
+    platform: stringColumn("platform"),
+    should_force_update: bool("should_force_update"),
+    enabled: bool("enabled"),
+    file_hash: stringColumn("file_hash"),
+    git_commit_hash: stringColumn("git_commit_hash").nullable(),
+    message: stringColumn("message").nullable(),
+    channel: stringColumn("channel").defaultTo("production"),
+    storage_uri: stringColumn("storage_uri"),
+    target_app_version: stringColumn("target_app_version").nullable(),
+    fingerprint_hash: stringColumn("fingerprint_hash").nullable(),
+    metadata: json("metadata").defaultTo({}),
+    rollout_cohort_count: integer("rollout_cohort_count").defaultTo(1000),
+    target_cohorts: json("target_cohorts").nullable(),
+  },
+  {
+    indexes: [
+      index("bundles_target_app_version_idx", ["target_app_version"]),
+      index("bundles_fingerprint_hash_idx", ["fingerprint_hash"]),
+      index("bundles_channel_idx", ["channel"]),
+      index("bundles_platform_idx", ["platform"], ["mongodb"]),
+      index("bundles_rollout_idx", ["rollout_cohort_count"]),
+    ],
+    checks: [
+      check({
+        name: "check_version_or_fingerprint",
+        expression:
+          "(target_app_version is not null) or (fingerprint_hash is not null)",
+        sqliteInline: true,
+      }),
+      check({
+        name: "bundles_rollout_cohort_count_check",
+        expression:
+          "rollout_cohort_count >= 0 and rollout_cohort_count <= 1000",
+        sqliteInline: true,
+      }),
+    ],
+  },
+);
 
 export const v0_29_0 = schema({
   version: "0.29.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"),
-      rollout_cohort_count: column("rollout_cohort_count", "integer").defaultTo(
-        1000,
-      ),
-      target_cohorts: column("target_cohorts", "json").nullable(),
-    }),
-  },
-  relations: {},
+  settingsTable: HOT_UPDATER_SETTINGS_TABLE,
+  tables: [bundlesV029, createSettingsTable("0.29.0")],
 });

package/src/schema/v0_31_0.spec.ts

@@ -0,0 +1,73 @@
+import { describe, expect, it } from "vitest";
+
+import { createTableStatement } from "../db/schema/sql";
+import { bundlePatchesV031, v0_31_0 } from "./v0_31_0";
+
+describe("bundlePatchesV031", () => {
+  it("uses the functional schema DSL for the v0.31.0 bundle patches table", () => {
+    expect(v0_31_0.dsl).toBe("schema");
+    expect(bundlePatchesV031.dsl).toBe("table");
+    expect(bundlePatchesV031.columns).toEqual([
+      { ormName: "id", type: "varchar(255)", primaryKey: true },
+      { ormName: "bundle_id", type: "uuid" },
+      { ormName: "base_bundle_id", type: "uuid" },
+      { ormName: "base_file_hash", type: "string" },
+      { ormName: "patch_file_hash", type: "string" },
+      { ormName: "patch_storage_uri", type: "string" },
+      {
+        ormName: "order_index",
+        type: "integer",
+        default: { type: "literal", value: 0 },
+      },
+    ]);
+    expect(bundlePatchesV031.indexes).toEqual([
+      { name: "bundle_patches_bundle_id_idx", columns: ["bundle_id"] },
+      {
+        name: "bundle_patches_base_bundle_id_idx",
+        columns: ["base_bundle_id"],
+      },
+    ]);
+    expect(bundlePatchesV031.foreignKeys).toEqual([
+      {
+        name: "bundle_patches_bundle_id_fk",
+        columns: ["bundle_id"],
+        referencedTable: "bundles",
+        referencedColumns: ["id"],
+        onUpdate: "restrict",
+        onDelete: "cascade",
+      },
+      {
+        name: "bundle_patches_base_bundle_id_fk",
+        columns: ["base_bundle_id"],
+        referencedTable: "bundles",
+        referencedColumns: ["id"],
+        onUpdate: "restrict",
+        onDelete: "cascade",
+      },
+    ]);
+    expect(bundlePatchesV031.relations).toEqual([
+      {
+        name: "bundle",
+        fieldName: "patches",
+        targetFieldName: "bundle",
+        relationName: "bundle_patches_bundles_patches",
+        columns: ["bundle_id"],
+        referencedTable: "bundles",
+        referencedColumns: ["id"],
+      },
+      {
+        name: "baseBundle",
+        fieldName: "baseForPatches",
+        targetFieldName: "baseBundle",
+        relationName: "bundle_patches_bundles_baseForPatches",
+        columns: ["base_bundle_id"],
+        referencedTable: "bundles",
+        referencedColumns: ["id"],
+      },
+    ]);
+    expect(Object.keys(bundlePatchesV031)).not.toContain("dsl");
+    expect(createTableStatement(bundlePatchesV031, "postgresql")).toContain(
+      "id varchar(255) primary key not null",
+    );
+  });
+});