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

package/src/adapters/databaseConstraintErrors.ts

@@ -0,0 +1,25 @@
+import { DatabaseRowReferencedError } from "@hot-updater/plugin-core/internal";
+
+const readErrorCode = (error: unknown): string | undefined => {
+  if (typeof error !== "object" || error === null) return undefined;
+  const code = Reflect.get(error, "code");
+  return typeof code === "string" ? code : undefined;
+};
+
+export const isChannelDeleteReferencedError = (error: unknown): boolean =>
+  error instanceof DatabaseRowReferencedError ||
+  [
+    "23503",
+    "SQLITE_CONSTRAINT_FOREIGNKEY",
+    "SQLITE_CONSTRAINT",
+    "ER_ROW_IS_REFERENCED",
+    "ER_ROW_IS_REFERENCED_2",
+    "P2003",
+  ].includes(readErrorCode(error) ?? "");
+
+export const translateChannelDeleteError = (error: unknown): never => {
+  if (isChannelDeleteReferencedError(error)) {
+    throw new DatabaseRowReferencedError();
+  }
+  throw error;
+};

package/src/adapters/databasePluginTestDatabase.ts

@@ -0,0 +1,106 @@
+export const DATABASE_PLUGIN_TEST_SCHEMA_SQL = `
+  create table channels (
+    id text primary key,
+    name text not null unique
+  );
+  create table bundles (
+    id text primary key,
+    platform text not null,
+    file_hash text not null,
+    git_commit_hash text,
+    storage_uri text not null,
+    archive_byte_size double precision not null check (
+      archive_byte_size >= 0 and archive_byte_size <= 9007199254740991
+    ),
+    metadata jsonb not null default '{}'::jsonb,
+    manifest_storage_uri text,
+    manifest_file_hash text,
+    asset_base_storage_uri text
+  );
+  create table bundle_patches (
+    id varchar(255) primary key,
+    bundle_id text not null references bundles(id) on delete cascade,
+    base_bundle_id text not null references bundles(id) on delete cascade,
+    base_file_hash text not null,
+    patch_file_hash text not null,
+    patch_storage_uri text not null,
+    byte_size double precision not null check (
+      byte_size >= 0 and byte_size <= 9007199254740991
+    ),
+    order_index integer not null default 0
+  );
+  create table releases (
+    id text primary key,
+    revision integer not null,
+    scope_key text not null,
+    channel_id text not null references channels(id),
+    platform text not null,
+    kind text not null,
+    bundle_id text references bundles(id),
+    strategy text not null,
+    target_app_version text,
+    fingerprint_hash text,
+    enabled boolean not null,
+    should_force_update boolean not null,
+    message text,
+    rollout_cohort_count integer not null default 1000,
+    target_cohorts jsonb not null default '[]'::jsonb,
+    operation text not null,
+    source_release_id text references releases(id) on delete set null,
+    created_at_ms integer not null,
+    updated_at_ms integer not null
+  );
+  create table release_catalogs (
+    scope_key text primary key,
+    catalog_id text not null,
+    strategy text not null,
+    channel_id text not null references channels(id),
+    channel_key text not null,
+    platform text not null,
+    fingerprint_hash text,
+    generation integer not null,
+    payload text not null,
+    catalog_hash text not null,
+    byte_size integer not null,
+    is_tombstone boolean not null,
+    updated_at_ms integer not null
+  );
+  create table bundle_events (
+    id text primary key,
+    type text not null,
+    install_id text not null,
+    user_id text,
+    username text,
+    from_release_id text,
+    from_bundle_id text,
+    to_release_id text,
+    to_bundle_id text not null,
+    platform text not null,
+    app_version text not null,
+    channel text not null,
+    cohort text not null,
+    update_strategy text,
+    fingerprint_hash text,
+    sdk_version text,
+    received_at_ms integer not null
+  );
+  create table api_keys (
+    id text primary key,
+    hash text not null unique,
+    name text not null,
+    prefix text not null,
+    role text not null,
+    created_at_ms integer not null,
+    revoked_at_ms integer
+  );
+`;
+
+export const DATABASE_PLUGIN_TEST_RESET_SQL = `
+  delete from bundle_events;
+  delete from api_keys;
+  delete from bundle_patches;
+  delete from release_catalogs;
+  delete from releases;
+  delete from bundles;
+  delete from channels;
+`;

package/src/adapters/databasePluginUtils.spec.ts

@@ -0,0 +1,29 @@
+import { describe, expect, it } from "vitest";
+
+import { createBundleRowFixture } from "../../../test-utils/src/databaseTestFixtures";
+import { fromStoredBundleRow } from "./databasePluginUtils";
+
+describe("fromStoredBundleRow", () => {
+  it("parses JSON-object metadata from SQL text storage", () => {
+    const row = fromStoredBundleRow({
+      ...createBundleRowFixture("valid-metadata"),
+      metadata: '{"release":{"flags":[true,null,3]}}',
+    });
+
+    expect(row.metadata).toEqual({
+      release: { flags: [true, null, 3] },
+    });
+  });
+
+  it.each(["null", "[]", "1", '"metadata"', "not-json"])(
+    "rejects non-object SQL metadata %s",
+    (metadata) => {
+      expect(() =>
+        fromStoredBundleRow({
+          ...createBundleRowFixture("invalid-metadata"),
+          metadata,
+        }),
+      ).toThrow("Invalid metadata");
+    },
+  );
+});

package/src/adapters/databasePluginUtils.ts

@@ -0,0 +1,214 @@
+import type {
+  BundleRow,
+  ReleaseCatalogRow,
+  ReleaseRow,
+  ReleaseRowUpdate,
+} from "@hot-updater/plugin-core";
+import { isDatabaseMetadataObject } from "@hot-updater/plugin-core";
+import type {
+  DatabaseModel,
+  DatabaseOrderBy,
+  DatabaseSortBy,
+} from "@hot-updater/plugin-core/internal";
+
+import type { ORMSQLProvider } from "../db/types";
+
+export type StoredBundleRow = Omit<BundleRow, "metadata"> & {
+  readonly metadata: unknown;
+};
+
+export type StoredReleaseRow = Omit<ReleaseRow, "target_cohorts"> & {
+  readonly target_cohorts: unknown;
+};
+
+export type StoredReleaseCatalogRow = Omit<
+  ReleaseCatalogRow,
+  "is_tombstone"
+> & {
+  readonly is_tombstone: unknown;
+};
+
+type AnyDatabaseSortBy = {
+  readonly [TModel in DatabaseModel]: DatabaseSortBy<TModel>;
+}[DatabaseModel];
+type AnyDatabaseOrderBy = {
+  readonly [TModel in DatabaseModel]: DatabaseOrderBy<TModel>;
+}[DatabaseModel];
+type AnyDatabaseOrderClause = AnyDatabaseSortBy;
+
+class StoredBundleRowError extends Error {
+  readonly name = "StoredBundleRowError";
+}
+
+const parseStoredBoolean = (value: unknown, field: string): boolean => {
+  if (value === true || value === 1) return true;
+  if (value === false || value === 0) return false;
+  throw new StoredBundleRowError(`Invalid boolean value for ${field}.`);
+};
+
+const parseJson = (value: string): unknown => {
+  try {
+    return JSON.parse(value);
+  } catch (error) {
+    if (error instanceof SyntaxError) return value;
+    throw error;
+  }
+};
+
+const parseTargetCohorts = (value: unknown): readonly string[] | null => {
+  if (value === null) return null;
+  const parsed = typeof value === "string" ? parseJson(value) : value;
+  if (
+    !Array.isArray(parsed) ||
+    !parsed.every((item) => typeof item === "string")
+  ) {
+    throw new StoredBundleRowError("Invalid target_cohorts field.");
+  }
+  return parsed;
+};
+
+const parseMetadata = (value: unknown) => {
+  const parsed = typeof value === "string" ? parseJson(value) : value;
+  if (!isDatabaseMetadataObject(parsed)) {
+    throw new StoredBundleRowError("Invalid metadata field.");
+  }
+  return parsed;
+};
+
+const compareOrderValues = (left: unknown, right: unknown): number => {
+  if (typeof left === "number" && typeof right === "number") {
+    return left - right;
+  }
+  if (typeof left === "string" && typeof right === "string") {
+    return left.localeCompare(right);
+  }
+  if (typeof left === "boolean" && typeof right === "boolean") {
+    return Number(left) - Number(right);
+  }
+  if (left === right) {
+    return 0;
+  }
+  return String(left).localeCompare(String(right));
+};
+
+const normalizeOrderBy = (
+  orderBy: AnyDatabaseOrderBy | readonly AnyDatabaseSortBy[] | undefined,
+): readonly AnyDatabaseOrderClause[] => {
+  if (orderBy === undefined) {
+    return [];
+  }
+  return (
+    Array.isArray(orderBy) ? orderBy : [orderBy]
+  ) as readonly AnyDatabaseOrderClause[];
+};
+
+export const hasNullOrderOverrides = (
+  orderBy: AnyDatabaseOrderBy | readonly AnyDatabaseSortBy[] | undefined,
+): boolean =>
+  normalizeOrderBy(orderBy).some((clause) => clause.nulls !== undefined);
+
+export const sortRowsByOrder = <TRow extends object>(
+  rows: readonly TRow[],
+  orderBy: AnyDatabaseOrderBy | readonly AnyDatabaseSortBy[] | undefined,
+): TRow[] => {
+  const clauses = normalizeOrderBy(orderBy);
+  if (clauses.length === 0) {
+    return [...rows];
+  }
+
+  return [...rows].toSorted((left, right) => {
+    for (const clause of clauses) {
+      const leftValue = Reflect.get(left, clause.field);
+      const rightValue = Reflect.get(right, clause.field);
+
+      if (leftValue == null || rightValue == null) {
+        if (leftValue == null && rightValue == null) {
+          continue;
+        }
+        const nulls =
+          clause.nulls ?? (clause.direction === "asc" ? "last" : "first");
+        const order = leftValue == null ? -1 : 1;
+        return nulls === "first" ? order : -order;
+      }
+
+      const result = compareOrderValues(leftValue, rightValue);
+      if (result !== 0) {
+        return clause.direction === "desc" ? -result : result;
+      }
+    }
+    return 0;
+  });
+};
+
+export const fromStoredBundleRow = (row: StoredBundleRow): BundleRow => ({
+  ...row,
+  metadata: parseMetadata(row.metadata),
+});
+
+export const toStoredBundleRow = (
+  row: BundleRow,
+  provider: ORMSQLProvider,
+): StoredBundleRow => {
+  if (provider !== "mysql" && provider !== "sqlite") return row;
+  return {
+    ...row,
+    metadata: JSON.stringify(row.metadata),
+  };
+};
+
+export const toStoredBundleUpdate = (
+  update: Partial<Omit<BundleRow, "id">>,
+  provider: ORMSQLProvider,
+): Partial<Omit<StoredBundleRow, "id">> => {
+  if (provider !== "mysql" && provider !== "sqlite") return update;
+  return {
+    ...update,
+    ...("metadata" in update
+      ? { metadata: JSON.stringify(update.metadata) }
+      : {}),
+  };
+};
+
+export const fromStoredReleaseRow = (row: StoredReleaseRow): ReleaseRow => ({
+  ...row,
+  enabled: parseStoredBoolean(row.enabled, "enabled"),
+  should_force_update: parseStoredBoolean(
+    row.should_force_update,
+    "should_force_update",
+  ),
+  target_cohorts: parseTargetCohorts(row.target_cohorts) ?? [],
+});
+
+export const toStoredReleaseRow = (
+  row: ReleaseRow,
+  provider: ORMSQLProvider,
+): StoredReleaseRow => {
+  if (provider !== "mysql" && provider !== "sqlite") return row;
+  return { ...row, target_cohorts: JSON.stringify(row.target_cohorts) };
+};
+
+export const toStoredReleaseUpdate = (
+  update: ReleaseRowUpdate,
+  provider: ORMSQLProvider,
+): Partial<Omit<StoredReleaseRow, "id">> => {
+  if (provider !== "mysql" && provider !== "sqlite") return update;
+  return {
+    ...update,
+    ...(update.target_cohorts === undefined
+      ? {}
+      : { target_cohorts: JSON.stringify(update.target_cohorts) }),
+  };
+};
+
+export const fromStoredReleaseCatalogRow = (
+  row: StoredReleaseCatalogRow,
+): ReleaseCatalogRow => ({
+  ...row,
+  is_tombstone: parseStoredBoolean(row.is_tombstone, "is_tombstone"),
+});
+
+export const escapeLikePattern = (value: string): string =>
+  value.replaceAll("\\", "\\\\").replaceAll("%", "\\%").replaceAll("_", "\\_");
+
+export const escapeGlobPattern = (value: string): string =>
+  value.replaceAll("[", "[[]").replaceAll("*", "[*]").replaceAll("?", "[?]");

package/src/adapters/drizzle.spec.ts

@@ -1,76 +1,237 @@
+import { PGlite } from "@electric-sql/pglite";
+import {
+  boolean,
+  doublePrecision,
+  integer,
+  jsonb,
+  pgTable,
+  text,
+  varchar,
+} from "drizzle-orm/pg-core";
+import { drizzle } from "drizzle-orm/pglite";
 import { describe, expect, it, vi } from "vitest";
 
-import { generateSchema } from "../db";
-import { createHotUpdater } from "../index";
+import { setupDatabasePluginTestSuite } from "../../../test-utils/src/setupDatabasePluginTestSuite";
+import type { DatabaseAdapterWithCapabilities } from "../db/types";
+import {
+  DATABASE_PLUGIN_TEST_RESET_SQL,
+  DATABASE_PLUGIN_TEST_SCHEMA_SQL,
+} from "./databasePluginTestDatabase";
 import { drizzleAdapter } from "./drizzle";
 
-describe("drizzleAdapter", () => {
-  it("generates schema without resolving a lazy runtime database", () => {
+const bundles = pgTable("bundles", {
+  id: text("id").primaryKey(),
+  platform: text("platform").notNull(),
+  file_hash: text("file_hash").notNull(),
+  git_commit_hash: text("git_commit_hash"),
+  storage_uri: text("storage_uri").notNull(),
+  archive_byte_size: doublePrecision("archive_byte_size").notNull(),
+  metadata: jsonb("metadata").notNull(),
+  manifest_storage_uri: text("manifest_storage_uri"),
+  manifest_file_hash: text("manifest_file_hash"),
+  asset_base_storage_uri: text("asset_base_storage_uri"),
+});
+const channels = pgTable("channels", {
+  id: text("id").primaryKey(),
+  name: text("name").notNull().unique(),
+});
+const releases = pgTable("releases", {
+  id: text("id").primaryKey(),
+  revision: integer("revision").notNull(),
+  scope_key: text("scope_key").notNull(),
+  channel_id: text("channel_id").notNull(),
+  platform: text("platform").notNull(),
+  kind: text("kind").notNull(),
+  bundle_id: text("bundle_id"),
+  strategy: text("strategy").notNull(),
+  target_app_version: text("target_app_version"),
+  fingerprint_hash: text("fingerprint_hash"),
+  enabled: boolean("enabled").notNull(),
+  should_force_update: boolean("should_force_update").notNull(),
+  message: text("message"),
+  rollout_cohort_count: integer("rollout_cohort_count").notNull(),
+  target_cohorts: jsonb("target_cohorts").notNull(),
+  operation: text("operation").notNull(),
+  source_release_id: text("source_release_id"),
+  created_at_ms: integer("created_at_ms").notNull(),
+  updated_at_ms: integer("updated_at_ms").notNull(),
+});
+const releaseCatalogs = pgTable("release_catalogs", {
+  scope_key: text("scope_key").primaryKey(),
+  catalog_id: text("catalog_id").notNull(),
+  strategy: text("strategy").notNull(),
+  channel_id: text("channel_id").notNull(),
+  channel_key: text("channel_key").notNull(),
+  platform: text("platform").notNull(),
+  fingerprint_hash: text("fingerprint_hash"),
+  generation: integer("generation").notNull(),
+  payload: text("payload").notNull(),
+  catalog_hash: text("catalog_hash").notNull(),
+  byte_size: integer("byte_size").notNull(),
+  is_tombstone: boolean("is_tombstone").notNull(),
+  updated_at_ms: integer("updated_at_ms").notNull(),
+});
+const bundlePatches = pgTable("bundle_patches", {
+  id: varchar("id", { length: 255 }).primaryKey(),
+  bundle_id: text("bundle_id").notNull(),
+  base_bundle_id: text("base_bundle_id").notNull(),
+  base_file_hash: text("base_file_hash").notNull(),
+  patch_file_hash: text("patch_file_hash").notNull(),
+  patch_storage_uri: text("patch_storage_uri").notNull(),
+  byte_size: doublePrecision("byte_size").notNull(),
+  order_index: integer("order_index").notNull(),
+});
+const bundleEvents = pgTable("bundle_events", {
+  id: text("id").primaryKey(),
+  type: text("type").notNull(),
+  install_id: text("install_id").notNull(),
+  user_id: text("user_id"),
+  username: text("username"),
+  from_release_id: text("from_release_id"),
+  from_bundle_id: text("from_bundle_id"),
+  to_release_id: text("to_release_id"),
+  to_bundle_id: text("to_bundle_id").notNull(),
+  platform: text("platform").notNull(),
+  app_version: text("app_version").notNull(),
+  channel: text("channel").notNull(),
+  cohort: text("cohort").notNull(),
+  update_strategy: text("update_strategy"),
+  fingerprint_hash: text("fingerprint_hash"),
+  sdk_version: text("sdk_version"),
+  received_at_ms: integer("received_at_ms").notNull(),
+});
+const apiKeys = pgTable("api_keys", {
+  id: text("id").primaryKey(),
+  hash: text("hash").notNull().unique(),
+  name: text("name").notNull(),
+  prefix: text("prefix").notNull(),
+  role: text("role").notNull(),
+  created_at_ms: integer("created_at_ms").notNull(),
+  revoked_at_ms: integer("revoked_at_ms"),
+});
+const schema = {
+  bundle_events: bundleEvents,
+  bundle_patches: bundlePatches,
+  bundles,
+  channels,
+  api_keys: apiKeys,
+  release_catalogs: releaseCatalogs,
+  releases,
+};
+
+class DrizzleTestStateError extends Error {
+  readonly name = "DrizzleTestStateError";
+}
+
+let client: PGlite | undefined;
+let database: ReturnType<typeof drizzle<typeof schema>> | undefined;
+
+const getClient = (): PGlite => {
+  if (client === undefined) throw new DrizzleTestStateError();
+  return client;
+};
+
+const getDatabase = (): ReturnType<typeof drizzle<typeof schema>> => {
+  if (database === undefined) throw new DrizzleTestStateError();
+  return database;
+};
+
+setupDatabasePluginTestSuite({
+  name: "drizzleAdapter PostgreSQL",
+  migrate: async () => {
+    client = new PGlite();
+    await client.exec(DATABASE_PLUGIN_TEST_SCHEMA_SQL);
+    database = drizzle(client, { schema });
+  },
+  createPlugin: (): DatabaseAdapterWithCapabilities =>
+    drizzleAdapter({ db: getDatabase(), provider: "postgresql" }),
+  reset: async () => {
+    await getClient().exec(DATABASE_PLUGIN_TEST_RESET_SQL);
+  },
+  dispose: async () => {
+    await getClient().close();
+    database = undefined;
+    client = undefined;
+  },
+});
+
+describe("drizzleAdapter schema requirements", () => {
+  it("does not resolve a lazy database while generating a schema", () => {
     const getDB = vi.fn(() => {
-      throw new Error("runtime database should not be opened");
+      throw new DrizzleTestStateError();
     });
-
-    const hotUpdater = createHotUpdater({
-      database: drizzleAdapter({
-        db: getDB,
-        provider: "postgresql",
-      }),
+    const plugin = drizzleAdapter({
+      db: getDB,
+      provider: "postgresql",
+      schema,
     });
 
-    const schema = generateSchema(hotUpdater, "latest");
+    const generated = plugin.generateSchema?.("latest");
 
-    expect(schema.path).toBe("hot-updater-schema.ts");
-    expect(schema.code).toContain("pgTable");
+    expect(generated?.code).toContain("pgTable");
     expect(getDB).not.toHaveBeenCalled();
   });
 
-  it("resolves a lazy runtime database only when a database operation runs", async () => {
-    const bundles = { channel: "channel" };
-    const bundlePatches = { bundle_id: "bundle_id" };
-    const db = {
-      _: { fullSchema: { bundle_patches: bundlePatches, bundles } },
-      $count: vi.fn(),
-      delete: vi.fn(),
-      insert: vi.fn(),
-      query: {
-        bundle_patches: {
-          findMany: vi.fn(),
-        },
-        bundles: {
-          findFirst: vi.fn(),
-          findMany: vi.fn(async () => [{ channel: "production" }]),
-        },
-      },
-      select: vi.fn(),
-      update: vi.fn(),
-    };
-    const getDB = vi.fn(async () => db);
-
+  it("resolves a lazy database on the first database operation", async () => {
+    const lazyClient = new PGlite();
+    await lazyClient.exec(DATABASE_PLUGIN_TEST_SCHEMA_SQL);
+    const lazyDatabase = drizzle(lazyClient, { schema });
+    const getDB = vi.fn(async () => lazyDatabase);
     const plugin = drizzleAdapter({
       db: getDB,
       provider: "postgresql",
-      schema: { bundle_patches: bundlePatches, bundles },
-    })();
-
-    expect(getDB).not.toHaveBeenCalled();
+      schema,
+    });
 
-    await expect(plugin.getChannels()).resolves.toEqual(["production"]);
-    expect(getDB).toHaveBeenCalledOnce();
+    try {
+      expect(getDB).not.toHaveBeenCalled();
+      await expect(plugin.models.channels.list({})).resolves.toEqual({
+        channels: [],
+      });
+      expect(getDB).toHaveBeenCalledOnce();
+    } finally {
+      await lazyClient.close();
+    }
   });
 
-  it("requires schema for lazy runtime database configs", async () => {
+  it("rejects a lazy database without a schema on first use", () => {
     const getDB = vi.fn(() => {
-      throw new Error("runtime database should not be opened");
+      throw new DrizzleTestStateError();
     });
+    const plugin = drizzleAdapter({ db: getDB, provider: "postgresql" });
+
+    expect(() => plugin.models.channels.list({})).toThrow(
+      "[hot-updater] Drizzle adapter requires schema when db is lazy.",
+    );
+    expect(getDB).not.toHaveBeenCalled();
+  });
 
+  it("rejects an invalid lazy database schema on first use", () => {
+    const getDB = vi.fn(() => {
+      throw new DrizzleTestStateError();
+    });
     const plugin = drizzleAdapter({
       db: getDB,
       provider: "postgresql",
-    })();
+      schema: { ...schema, bundles: null },
+    });
 
-    await expect(plugin.getChannels()).rejects.toThrow(
-      "[hot-updater] Drizzle adapter requires schema when db is lazy.",
+    expect(() => plugin.models.channels.list({})).toThrow(
+      '[hot-updater] Drizzle schema table "bundles" is invalid.',
     );
     expect(getDB).not.toHaveBeenCalled();
   });
+
+  it("requires all fixed table objects on first use", () => {
+    const incompleteSchema = { bundles };
+    const plugin = drizzleAdapter({
+      db: () => getDatabase(),
+      provider: "postgresql",
+      schema: incompleteSchema,
+    });
+
+    expect(() => plugin.models.channels.list({})).toThrow(
+      'Drizzle schema is missing table "bundle_patches".',
+    );
+  });
 });