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

package/src/runtime.testFixtures.ts

@@ -0,0 +1,71 @@
+import type { Bundle } from "@hot-updater/core";
+import type {
+  DatabasePlugin,
+  StoragePlugin,
+  StoragePluginWith,
+} from "@hot-updater/plugin-core";
+import { createStoragePlugin } from "@hot-updater/plugin-core";
+
+import { createInMemoryDatabasePlugin } from "../../test-utils/test/inMemoryDatabasePlugin";
+import type { DatabaseAdapterCapabilities, Migrator } from "./db/types";
+
+export const runtimeBundle: Bundle = {
+  id: "00000000-0000-0000-0000-000000000001",
+  platform: "ios",
+  fileHash: "hash123",
+  gitCommitHash: null,
+  storageUri: "s3://test-bucket/bundles/bundle.zip",
+  archiveByteSize: 3_000_000_001,
+};
+
+export const createRuntimeStorage = (
+  get: NonNullable<StoragePlugin["get"]> = async () => ({ response: null }),
+  getDownloadUrl?: StoragePlugin["getDownloadUrl"],
+): StoragePluginWith<"get"> =>
+  createStoragePlugin({
+    name: "testStorage",
+    protocol: "s3",
+    get,
+    ...(getDownloadUrl ? { getDownloadUrl } : {}),
+  });
+
+const createMigrator = (version: string | undefined): Migrator => ({
+  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");
+  },
+});
+
+export const createRuntimeDatabase = (): DatabasePlugin => ({
+  ...createInMemoryDatabasePlugin(),
+  name: "testDatabase",
+});
+
+export const createSchemaManagedDatabase = (
+  adapterName: string,
+  version: string | undefined,
+): DatabasePlugin & DatabaseAdapterCapabilities => ({
+  ...createRuntimeDatabase(),
+  adapterName,
+  createMigrator: () => createMigrator(version),
+});

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

@@ -1,26 +1,35 @@
 import { describe, expect, it } from "vitest";
 
+import { hotUpdaterSchemaVersions } from "./index";
 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";
+import {
+  bundlePatchesV100,
+  bundlesV100,
+  channelsV100,
+  releaseCatalogsV100,
+  releasesV100,
+  v1_0_0,
+} from "./v1_0_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");
+  it("uses the local functional DSL for the current schema", () => {
+    expect(v1_0_0.dsl).toBe("schema");
+    expect(channelsV100.dsl).toBe("table");
+    expect(bundlesV100.dsl).toBe("table");
+    expect(bundlePatchesV100.dsl).toBe("table");
+    expect(releasesV100.dsl).toBe("table");
+    expect(releaseCatalogsV100.dsl).toBe("table");
+    expect(createSettingsTable("1.0.0").dsl).toBe("table");
 
-    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");
-      }
+    expect(Object.keys(v1_0_0)).not.toContain("dsl");
+    for (const table of v1_0_0.tables) {
+      expect(Object.keys(table)).not.toContain("dsl");
     }
   });
+
+  it("registers only schema 1.0.0", () => {
+    expect(hotUpdaterSchemaVersions.map((item) => item.version)).toEqual([
+      "1.0.0",
+    ]);
+  });
 });

package/src/schema/dsl.ts

@@ -10,7 +10,12 @@ import type {
   HotUpdaterVersionedSchema,
 } from "./types";
 
-type DefaultValue = boolean | number | string | Record<string, unknown>;
+type DefaultValue =
+  | boolean
+  | number
+  | string
+  | Record<string, unknown>
+  | readonly unknown[];
 
 export type HotUpdaterColumnDsl = {
   readonly dsl: "column";
@@ -19,8 +24,14 @@ export type HotUpdaterColumnDsl = {
   readonly default?: HotUpdaterDefault;
   readonly nullableValue?: true;
   readonly primaryKeyValue?: true;
+  readonly providerCollations?: HotUpdaterColumnSchema["providerCollations"];
   readonly nullable: () => HotUpdaterColumnDsl;
   readonly primaryKey: () => HotUpdaterColumnDsl;
+  readonly collate: (
+    providerCollations: NonNullable<
+      HotUpdaterColumnSchema["providerCollations"]
+    >,
+  ) => HotUpdaterColumnDsl;
   readonly defaultTo: (value: DefaultValue) => HotUpdaterColumnDsl;
 };
 
@@ -45,6 +56,9 @@ const defaultValue = (value: DefaultValue): HotUpdaterDefault =>
 const columnSchema = (column: HotUpdaterColumnDsl): HotUpdaterColumnSchema => ({
   ormName: column.ormName,
   type: column.type,
+  ...(column.providerCollations
+    ? { providerCollations: column.providerCollations }
+    : {}),
   ...(column.nullableValue ? { nullable: true } : {}),
   ...(column.primaryKeyValue ? { primaryKey: true } : {}),
   ...(column.default ? { default: column.default } : {}),
@@ -59,11 +73,16 @@ const createColumn = (state: ColumnState): HotUpdaterColumnDsl => ({
   dsl: "column",
   ormName: state.ormName,
   type: state.type,
+  ...(state.providerCollations
+    ? { providerCollations: state.providerCollations }
+    : {}),
   ...(state.nullableValue ? { nullableValue: true } : {}),
   ...(state.primaryKeyValue ? { primaryKeyValue: true } : {}),
   ...(state.default ? { default: state.default } : {}),
   nullable: () => createColumn({ ...state, nullableValue: true }),
   primaryKey: () => createColumn({ ...state, primaryKeyValue: true }),
+  collate: (providerCollations) =>
+    createColumn({ ...state, providerCollations }),
   defaultTo: (value) =>
     createColumn({ ...state, default: defaultValue(value) }),
 });
@@ -88,6 +107,9 @@ export const uuid = (ormName: string): HotUpdaterColumnDsl =>
 export const integer = (ormName: string): HotUpdaterColumnDsl =>
   column(ormName, "integer");
 
+export const float = (ormName: string): HotUpdaterColumnDsl =>
+  column(ormName, "float");
+
 export const bool = (ormName: string): HotUpdaterColumnDsl =>
   column(ormName, "bool");
 
@@ -97,6 +119,9 @@ export const json = (ormName: string): HotUpdaterColumnDsl =>
 export const stringColumn = (ormName: string): HotUpdaterColumnDsl =>
   column(ormName, "string");
 
+export const largeString = (ormName: string): HotUpdaterColumnDsl =>
+  column(ormName, "large-string");
+
 export const index = (
   name: string,
   columns: readonly string[],
@@ -107,18 +132,32 @@ export const index = (
   ...(providers ? { providers } : {}),
 });
 
+export const uniqueIndex = (
+  name: string,
+  columns: readonly string[],
+  providers?: HotUpdaterIndexSchema["providers"],
+): HotUpdaterIndexSchema => ({
+  name,
+  columns,
+  ...(providers ? { providers } : {}),
+  unique: true,
+});
+
 export const foreignKey = (
   name: string,
   columns: readonly string[],
   referencedTable: string,
   referencedColumns: readonly string[],
+  options: {
+    readonly onDelete?: HotUpdaterForeignKeySchema["onDelete"];
+  } = {},
 ): HotUpdaterForeignKeySchema => ({
   name,
   columns,
   referencedTable,
   referencedColumns,
   onUpdate: "restrict",
-  onDelete: "cascade",
+  onDelete: options.onDelete ?? "cascade",
 });
 
 export const check = (config: HotUpdaterCheckSchema): HotUpdaterCheckSchema =>

package/src/schema/index.ts

@@ -1,16 +1,10 @@
 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";
+import { v1_0_0 } from "./v1_0_0";
 
 export * from "./settings";
 export * from "./types";
-export * from "./v0_21_0";
-export * from "./v0_29_0";
-export * from "./v0_31_0";
+export * from "./v1_0_0";
 
 export const hotUpdaterSchemaVersions: readonly HotUpdaterVersionedSchema[] = [
-  v0_21_0,
-  v0_29_0,
-  v0_31_0,
+  v1_0_0,
 ];

package/src/schema/types.ts

@@ -1,12 +1,15 @@
 import type { ORMProvider } from "../db/types";
 
-export const HOT_UPDATER_SCHEMA_VERSION = "0.31.0";
+export const HOT_UPDATER_SCHEMA_VERSION = "1.0.0";
+export const HOT_UPDATER_CORE_SCHEMA_KEY = "schema.core";
 export const HOT_UPDATER_SETTINGS_TABLE = "private_hot_updater_settings";
 
 export type HotUpdaterColumnType =
   | "bool"
+  | "float"
   | "integer"
   | "json"
+  | "large-string"
   | "string"
   | "uuid"
   | `varchar(${number})`;
@@ -18,6 +21,7 @@ export type HotUpdaterDefault =
 export interface HotUpdaterColumnSchema {
   readonly ormName: string;
   readonly type: HotUpdaterColumnType;
+  readonly providerCollations?: Partial<Record<ORMProvider, string>>;
   readonly nullable?: boolean;
   readonly primaryKey?: boolean;
   readonly default?: HotUpdaterDefault;
@@ -27,11 +31,13 @@ export interface HotUpdaterIndexSchema {
   readonly name: string;
   readonly columns: readonly string[];
   readonly providers?: readonly ORMProvider[];
+  readonly unique?: true;
 }
 
 export interface HotUpdaterCheckSchema {
   readonly name: string;
   readonly expression: string;
+  readonly providerExpressions?: Partial<Record<ORMProvider, string>>;
   readonly sqliteInline?: boolean;
 }
 
@@ -41,7 +47,7 @@ export interface HotUpdaterForeignKeySchema {
   readonly referencedTable: string;
   readonly referencedColumns: readonly string[];
   readonly onUpdate: "restrict";
-  readonly onDelete: "cascade";
+  readonly onDelete: "cascade" | "restrict" | "set null";
 }
 
 export interface HotUpdaterRelationSchema {
@@ -70,4 +76,4 @@ export interface HotUpdaterVersionedSchema {
   readonly tables: readonly HotUpdaterTableSchema[];
 }
 
-export type HotUpdaterSchemaVersion = "0.21.0" | "0.29.0" | "0.31.0";
+export type HotUpdaterSchemaVersion = "1.0.0";

package/src/schema/v1_0_0.spec.ts

@@ -0,0 +1,146 @@
+import { describe, expect, it } from "vitest";
+
+import { createTableSql } from "../db/schema/sql";
+import {
+  generateDrizzleSchema,
+  generatePrismaSchema,
+} from "../db/schemaGenerators";
+import {
+  bundleEventsV100,
+  bundlePatchesV100,
+  bundlesV100,
+  releaseCatalogsV100,
+  releasesV100,
+  v1_0_0,
+} from "./v1_0_0";
+
+describe("v1.0.0 Release Catalog schema", () => {
+  it("adds the canonical Release and catalog access paths", () => {
+    expect(v1_0_0.tables.map(({ ormName }) => ormName)).toContain("releases");
+    expect(v1_0_0.tables.map(({ ormName }) => ormName)).toContain(
+      "release_catalogs",
+    );
+    expect(releasesV100.indexes).toContainEqual({
+      columns: ["scope_key", "id"],
+      name: "releases_scope_order_idx",
+    });
+    expect(
+      releaseCatalogsV100.columns.find(({ ormName }) => ormName === "scope_key")
+        ?.primaryKey,
+    ).toBe(true);
+  });
+
+  it("keeps only immutable artifact fields on Bundle rows", () => {
+    const fields = bundlesV100.columns.map(({ ormName }) => ormName);
+
+    expect(fields).toEqual([
+      "id",
+      "platform",
+      "file_hash",
+      "git_commit_hash",
+      "storage_uri",
+      "archive_byte_size",
+      "metadata",
+      "manifest_storage_uri",
+      "manifest_file_hash",
+      "asset_base_storage_uri",
+    ]);
+    expect(fields).not.toContain("channel_id");
+    expect(fields).not.toContain("enabled");
+    expect(fields).not.toContain("target_app_version");
+  });
+
+  it("stores required archive and patch sizes as bounded floating columns", () => {
+    const archiveSize = bundlesV100.columns.find(
+      ({ ormName }) => ormName === "archive_byte_size",
+    );
+    const patchSize = bundlePatchesV100.columns.find(
+      ({ ormName }) => ormName === "byte_size",
+    );
+    const sql = createTableSql("postgresql").join("\n");
+    const prisma = generatePrismaSchema("postgresql", v1_0_0);
+    const drizzle = generateDrizzleSchema("postgresql", v1_0_0);
+
+    expect(archiveSize?.type).toBe("float");
+    expect(archiveSize?.nullable).toBeUndefined();
+    expect(patchSize?.type).toBe("float");
+    expect(patchSize?.nullable).toBeUndefined();
+    expect(sql).toContain("archive_byte_size double precision not null");
+    expect(sql).toContain("byte_size double precision not null");
+    expect(sql).toContain("archive_byte_size <= 9007199254740991");
+    expect(sql).toContain("byte_size <= 9007199254740991");
+    expect(prisma).toContain("archive_byte_size Float");
+    expect(prisma).toContain("byte_size Float");
+    expect(drizzle).toContain(
+      'archive_byte_size: doublePrecision("archive_byte_size").notNull()',
+    );
+    expect(drizzle).toContain(
+      'byte_size: doublePrecision("byte_size").notNull()',
+    );
+  });
+
+  it("keeps nullable sources while requiring the reported target Bundle", () => {
+    for (const field of [
+      "from_release_id",
+      "to_release_id",
+      "from_bundle_id",
+    ]) {
+      expect(
+        bundleEventsV100.columns.find(({ ormName }) => ormName === field)
+          ?.nullable,
+      ).toBe(true);
+    }
+    expect(
+      bundleEventsV100.columns.find(({ ormName }) => ormName === "to_bundle_id")
+        ?.nullable,
+    ).toBeUndefined();
+  });
+
+  it("generates nullable source and artifact relations with the intended deletion rules", () => {
+    const prisma = generatePrismaSchema("postgresql", v1_0_0);
+    const drizzle = generateDrizzleSchema("postgresql", v1_0_0);
+
+    expect(prisma).toContain("model releases {");
+    expect(prisma).toContain("sourceRelease releases? @relation(");
+    expect(prisma).toContain("onDelete: SetNull");
+    expect(prisma).toContain("bundle bundles? @relation(");
+    expect(drizzle).toContain("export const release_catalogs = pgTable(");
+    expect(drizzle).toContain('index("releases_scope_order_idx")');
+    expect(drizzle).toContain("foreignColumns: [table.id]");
+    expect(drizzle).not.toContain("foreignColumns: [releases.id]");
+  });
+
+  it("creates both projection tables and their constraints from empty", () => {
+    const sql = createTableSql("postgresql").join("\n");
+
+    expect(sql).toContain("create table releases");
+    expect(sql).toContain("create table release_catalogs");
+    expect(sql).toContain("releases_scope_order_idx");
+    expect(sql).toContain("release_catalogs_generation_check");
+    expect(sql).toContain("to_bundle_id uuid not null");
+    expect(sql).toContain("from_bundle_id is not null");
+    expect(sql).toContain("type = 'UNCHANGED' and from_bundle_id is null");
+    expect(sql).toContain("on delete set null");
+  });
+
+  it("uses byte-bounded MySQL catalog keys", () => {
+    const sql = createTableSql("mysql").join("\n");
+
+    expect(sql).toContain(
+      "scope_key varchar(2048) character set ascii collate ascii_bin",
+    );
+    expect(sql).toContain(
+      "channel_key varchar(1400) character set ascii collate ascii_bin",
+    );
+    expect(sql).toContain(
+      "create index releases_scope_order_idx on releases(scope_key, id)",
+    );
+    expect(sql).toContain("payload mediumtext not null");
+    expect(generatePrismaSchema("mysql", v1_0_0)).toContain(
+      "payload String @db.MediumText",
+    );
+    expect(generateDrizzleSchema("mysql", v1_0_0)).toContain(
+      'payload: mediumtext("payload").notNull()',
+    );
+  });
+});