@hot-updater/server 0.33.2 → 0.34.0

package/src/db/schemaGenerators.ts

@@ -0,0 +1,382 @@
+import {
+  HOT_UPDATER_SETTINGS_TABLE,
+  type HotUpdaterColumnSchema,
+  type HotUpdaterColumnType,
+  type HotUpdaterDefault,
+  type HotUpdaterRelationSchema,
+  type HotUpdaterTableSchema,
+  type HotUpdaterVersionedSchema,
+} from "../schema/types";
+import {
+  getHotUpdaterSchemaVersion,
+  hotUpdaterSchema,
+  schemaIndexAppliesToProvider,
+} from "./schema/registry";
+import type { ORMProvider, ORMSQLProvider, SchemaGenerator } from "./types";
+import { getSQLProvider } from "./types";
+
+const literal = (value: string): string => JSON.stringify(value);
+
+const toPascalCase = (value: string): string =>
+  value
+    .split("_")
+    .filter(Boolean)
+    .map((part) => `${part.charAt(0).toUpperCase()}${part.slice(1)}`)
+    .join("");
+
+const prismaDb = (type: HotUpdaterColumnType, provider: ORMProvider) => {
+  if (provider === "postgresql") {
+    if (type === "uuid") return " @db.Uuid";
+    if (type.startsWith("varchar")) return " @db.VarChar(255)";
+  }
+  if (provider === "mysql") {
+    if (type === "uuid") return " @db.Char(36)";
+    if (type.startsWith("varchar")) return " @db.VarChar(255)";
+  }
+  return "";
+};
+
+const prismaType = (
+  column: HotUpdaterColumnSchema,
+  provider: ORMProvider,
+): string => {
+  const base = (() => {
+    if (column.type === "bool") return "Boolean";
+    if (column.type === "integer") return "Int";
+    if (column.type === "json") return "Json";
+    return "String";
+  })();
+  return `${base}${column.nullable ? "?" : ""}${prismaDb(
+    column.type,
+    provider,
+  )}`;
+};
+
+const prismaDefault = (
+  column: HotUpdaterColumnSchema,
+  provider: ORMProvider,
+): string => {
+  if (!column.default) return "";
+  if (provider === "sqlite" && column.type === "json") return "";
+  if (column.default.type === "json") {
+    return ` @default(${literal(JSON.stringify(column.default.value))})`;
+  }
+  return ` @default(${JSON.stringify(column.default.value)})`;
+};
+
+const prismaField = (
+  column: HotUpdaterColumnSchema,
+  provider: ORMProvider,
+): string =>
+  [
+    column.ormName,
+    prismaType(column, provider),
+    column.primaryKey ? "@id" : undefined,
+    prismaDefault(column, provider).trim() || undefined,
+  ]
+    .filter(Boolean)
+    .join(" ");
+
+const relationTargetFields = (
+  table: HotUpdaterTableSchema,
+  schema: HotUpdaterVersionedSchema,
+): readonly HotUpdaterRelationSchema[] =>
+  schema.tables.flatMap((sourceTable) =>
+    (sourceTable.relations ?? []).filter(
+      (relation) => relation.referencedTable === table.ormName,
+    ),
+  );
+
+const prismaRelationFields = (
+  table: HotUpdaterTableSchema,
+  schema: HotUpdaterVersionedSchema,
+): string[] => {
+  const lines = relationTargetFields(table, schema).map(
+    (relation) =>
+      `${relation.fieldName} ${relation.referencedTable === table.ormName ? "bundle_patches" : relation.referencedTable}[] @relation(${literal(relation.relationName)})`,
+  );
+
+  for (const relation of table.relations ?? []) {
+    const targetType = toPascalCase(relation.referencedTable);
+    lines.push(
+      `${relation.targetFieldName} ${targetType === "Bundles" ? "bundles" : relation.referencedTable} @relation(${literal(relation.relationName)}, fields: [${relation.columns.join(", ")}], references: [${relation.referencedColumns.join(", ")}], onUpdate: Restrict, onDelete: Cascade)`,
+    );
+  }
+
+  return lines;
+};
+
+const prismaIndexes = (
+  table: HotUpdaterTableSchema,
+  provider: ORMProvider,
+): string[] =>
+  (table.indexes ?? [])
+    .filter((index) => schemaIndexAppliesToProvider(index, provider))
+    .map(
+      (index) =>
+        `@@index([${index.columns.join(", ")}], map: ${literal(index.name)})`,
+    );
+
+export const generatePrismaSchema = (
+  provider: ORMProvider,
+  schema: HotUpdaterVersionedSchema = hotUpdaterSchema,
+) =>
+  schema.tables
+    .map((table) => {
+      const lines = [
+        ...table.columns.map((column) => prismaField(column, provider)),
+        ...prismaRelationFields(table, schema),
+        ...prismaIndexes(table, provider),
+      ];
+      return `model ${table.ormName} {\n${lines
+        .map((line) => `  ${line}`)
+        .join("\n")}\n}`;
+    })
+    .join("\n\n");
+
+const drizzleImportSource = (provider: ORMSQLProvider) =>
+  provider === "sqlite"
+    ? "drizzle-orm/sqlite-core"
+    : provider === "mysql"
+      ? "drizzle-orm/mysql-core"
+      : "drizzle-orm/pg-core";
+
+const drizzleTableFn = (provider: ORMSQLProvider) =>
+  provider === "sqlite"
+    ? "sqliteTable"
+    : provider === "mysql"
+      ? "mysqlTable"
+      : "pgTable";
+
+const drizzleColumnFn = (
+  column: HotUpdaterColumnSchema,
+  provider: ORMSQLProvider,
+): { code: string; imports: readonly string[] } => {
+  if (provider === "sqlite") {
+    if (column.type === "bool") {
+      return {
+        code: `integer(${literal(column.ormName)}, { mode: "boolean" })`,
+        imports: ["integer"],
+      };
+    }
+    if (column.type === "integer") {
+      return {
+        code: `integer(${literal(column.ormName)})`,
+        imports: ["integer"],
+      };
+    }
+    if (column.type === "json") {
+      return {
+        code: `blob(${literal(column.ormName)}, { mode: "json" })`,
+        imports: ["blob"],
+      };
+    }
+    if (column.type.startsWith("varchar")) {
+      return {
+        code: `text(${literal(column.ormName)}, { length: 255 })`,
+        imports: ["text"],
+      };
+    }
+    return { code: `text(${literal(column.ormName)})`, imports: ["text"] };
+  }
+
+  if (provider === "mysql") {
+    if (column.type === "uuid") {
+      return {
+        code: `char(${literal(column.ormName)}, { length: 36 })`,
+        imports: ["char"],
+      };
+    }
+    if (column.type === "bool") {
+      return {
+        code: `boolean(${literal(column.ormName)})`,
+        imports: ["boolean"],
+      };
+    }
+    if (column.type === "integer") {
+      return { code: `int(${literal(column.ormName)})`, imports: ["int"] };
+    }
+    if (column.type === "json") {
+      return { code: `json(${literal(column.ormName)})`, imports: ["json"] };
+    }
+    if (column.type.startsWith("varchar")) {
+      return {
+        code: `varchar(${literal(column.ormName)}, { length: 255 })`,
+        imports: ["varchar"],
+      };
+    }
+    return { code: `text(${literal(column.ormName)})`, imports: ["text"] };
+  }
+
+  if (column.type === "uuid") {
+    return { code: `uuid(${literal(column.ormName)})`, imports: ["uuid"] };
+  }
+  if (column.type === "bool") {
+    return {
+      code: `boolean(${literal(column.ormName)})`,
+      imports: ["boolean"],
+    };
+  }
+  if (column.type === "integer") {
+    return {
+      code: `integer(${literal(column.ormName)})`,
+      imports: ["integer"],
+    };
+  }
+  if (column.type === "json") {
+    return { code: `json(${literal(column.ormName)})`, imports: ["json"] };
+  }
+  if (column.type.startsWith("varchar")) {
+    return {
+      code: `varchar(${literal(column.ormName)}, { length: 255 })`,
+      imports: ["varchar"],
+    };
+  }
+  return { code: `text(${literal(column.ormName)})`, imports: ["text"] };
+};
+
+const drizzleDefault = (value: HotUpdaterDefault | undefined): string => {
+  if (!value) return "";
+  if (value.type === "json") return ".default({})";
+  return `.default(${JSON.stringify(value.value)})`;
+};
+
+const drizzleColumn = (
+  table: HotUpdaterTableSchema,
+  column: HotUpdaterColumnSchema,
+): HotUpdaterColumnSchema => {
+  if (table.ormName !== HOT_UPDATER_SETTINGS_TABLE) return column;
+  if (column.ormName === "key") {
+    return { ...column, ormName: "id", type: "varchar(255)" };
+  }
+  if (column.ormName === "value") {
+    return { ...column, ormName: "version", type: "varchar(255)" };
+  }
+  return column;
+};
+
+const drizzleTable = (
+  table: HotUpdaterTableSchema,
+  provider: ORMSQLProvider,
+  imports: Set<string>,
+): string => {
+  const columns = table.columns.map((sourceColumn) => {
+    const column = drizzleColumn(table, sourceColumn);
+    const type = drizzleColumnFn(column, provider);
+    for (const item of type.imports) imports.add(item);
+    const chain = [
+      type.code,
+      column.primaryKey ? "primaryKey()" : undefined,
+      column.nullable ? undefined : "notNull()",
+      drizzleDefault(column.default).slice(1) || undefined,
+    ].filter(Boolean);
+    return `  ${column.ormName}: ${chain.join(".")}`;
+  });
+
+  const callbacks: string[] = [];
+  for (const foreignKey of table.foreignKeys ?? []) {
+    imports.add("foreignKey");
+    callbacks.push(`foreignKey({
+    columns: [table.${foreignKey.columns.join(", table.")}],
+    foreignColumns: [${foreignKey.referencedTable}.${foreignKey.referencedColumns.join(
+      `, ${foreignKey.referencedTable}.`,
+    )}],
+    name: ${literal(foreignKey.name)}
+  }).onUpdate(${literal(foreignKey.onUpdate)}).onDelete(${literal(
+    foreignKey.onDelete,
+  )})`);
+  }
+  for (const index of (table.indexes ?? []).filter((item) =>
+    schemaIndexAppliesToProvider(item, provider),
+  )) {
+    imports.add("index");
+    callbacks.push(
+      `index(${literal(index.name)}).on(${index.columns
+        .map((column) => `table.${column}`)
+        .join(", ")})`,
+    );
+  }
+
+  const args = [
+    literal(table.ormName),
+    `{\n${columns.join(",\n")}\n}`,
+    callbacks.length > 0
+      ? `(table) => [\n${callbacks.map((line) => `  ${line}`).join(",\n")}\n]`
+      : undefined,
+  ].filter(Boolean);
+
+  return `export const ${table.ormName} = ${drizzleTableFn(provider)}(${args.join(
+    ", ",
+  )})`;
+};
+
+const drizzleRelations = (table: HotUpdaterTableSchema): string | undefined => {
+  if (!table.relations || table.relations.length === 0) return undefined;
+  const lines = table.relations.map(
+    (
+      relation,
+    ) => `  ${relation.targetFieldName}: one(${relation.referencedTable}, {
+    relationName: ${literal(relation.relationName)},
+    fields: [${relation.columns.map((column) => `${table.ormName}.${column}`).join(", ")}],
+    references: [${relation.referencedColumns
+      .map((column) => `${relation.referencedTable}.${column}`)
+      .join(", ")}]
+  })`,
+  );
+  return `export const ${table.ormName}Relations = relations(${table.ormName}, ({ one }) => ({
+${lines.join(",\n")}
+}))`;
+};
+
+export const generateDrizzleSchema = (
+  provider: ORMSQLProvider,
+  schema: HotUpdaterVersionedSchema = hotUpdaterSchema,
+) => {
+  const imports = new Set<string>([drizzleTableFn(provider)]);
+  const body: string[] = [];
+
+  for (const table of schema.tables) {
+    body.push(drizzleTable(table, provider, imports));
+    const relations = drizzleRelations(table);
+    if (relations) body.push(relations);
+  }
+
+  if (body.some((block) => block.includes("relations("))) {
+    body.unshift('import { relations } from "drizzle-orm"');
+  }
+
+  const importLine = `import { ${Array.from(imports)
+    .sort()
+    .join(", ")} } from "${drizzleImportSource(provider)}"`;
+
+  return [importLine, ...body].join("\n\n");
+};
+
+export const generateSchemaFromHotUpdaterSchema = (
+  adapterName: string,
+  provider: ORMProvider | undefined,
+  version: string | "latest",
+  fallback: ReturnType<SchemaGenerator>,
+): ReturnType<SchemaGenerator> => {
+  const schema =
+    version === "latest"
+      ? hotUpdaterSchema
+      : getHotUpdaterSchemaVersion(version);
+
+  if (adapterName === "prisma" && provider) {
+    return {
+      ...fallback,
+      code: generatePrismaSchema(provider, schema),
+    };
+  }
+
+  const sqlProvider = getSQLProvider(provider);
+  if (adapterName === "drizzle" && sqlProvider) {
+    return {
+      ...fallback,
+      code: generateDrizzleSchema(sqlProvider, schema),
+    };
+  }
+
+  return fallback;
+};

package/src/db/schemaReadiness.ts

@@ -0,0 +1,33 @@
+import { HOT_UPDATER_SCHEMA_VERSION } from "../schema/types";
+import type { Migrator } from "./types";
+
+export class HotUpdaterSchemaMigrationRequiredError extends Error {
+  constructor(
+    readonly adapterName: string,
+    readonly currentVersion: string | undefined,
+  ) {
+    super(
+      currentVersion === undefined
+        ? `Hot Updater database schema is not initialized for ${adapterName}. Run \`hot-updater db migrate\` before using this adapter.`
+        : `Hot Updater database schema version ${currentVersion} is not supported by ${adapterName}. Run \`hot-updater db migrate\` to upgrade to ${HOT_UPDATER_SCHEMA_VERSION}.`,
+    );
+    this.name = "HotUpdaterSchemaMigrationRequiredError";
+  }
+}
+
+export const createSchemaReadinessChecker = (
+  adapterName: string,
+  createMigrator: (() => Migrator) | undefined,
+): (() => Promise<void>) => {
+  if (!createMigrator) return async () => {};
+
+  let ready = false;
+  return async () => {
+    if (ready) return;
+    const version = await createMigrator().getVersion();
+    if (version !== HOT_UPDATER_SCHEMA_VERSION) {
+      throw new HotUpdaterSchemaMigrationRequiredError(adapterName, version);
+    }
+    ready = true;
+  };
+};

package/src/db/types.ts

@@ -10,34 +10,84 @@ import type {
   HotUpdaterContext,
   RuntimeStoragePlugin,
 } from "@hot-updater/plugin-core";
-import { sqlProviders, type Provider, type SQLProvider } from "fumadb";
 
 import type { PaginatedResult } from "../types";
 
 export type DatabasePluginFactory<TContext = unknown> =
-  () => DatabasePlugin<TContext>;
+  (() => DatabasePlugin<TContext>) & Partial<DatabaseAdapterCapabilities>;
 
-export type ORMProvider = Provider;
-export type ORMSQLProvider = SQLProvider;
+export const sqlProviders = [
+  "sqlite",
+  "cockroachdb",
+  "mysql",
+  "postgresql",
+  "mssql",
+] as const;
 
-export interface ORMDatabaseAdapter {
-  name: string;
+export const noSqlProviders = ["mongodb"] as const;
+export const providers = [...sqlProviders, ...noSqlProviders] as const;
+
+export type ORMProvider = (typeof providers)[number];
+export type ORMSQLProvider = (typeof sqlProviders)[number];
+export type RelationMode = "foreign-keys" | "fumadb";
+
+export interface MigrateOptions {
+  mode?: "from-schema" | "from-database";
+  updateSettings?: boolean;
+  unsafe?: boolean;
+}
+
+export type MigrationOperation =
+  | {
+      type: "create-table";
+      value: {
+        ormName: string;
+        columns: Record<string, { ormName: string; type: string }>;
+      };
+    }
+  | { type: "custom"; sql: string }
+  | { type: "custom"; key: string; value: unknown };
+
+export interface MigrationResult {
+  operations: MigrationOperation[];
+  execute: () => Promise<void>;
+  getSQL?: () => string;
+}
+
+export interface Migrator {
+  getVersion: () => Promise<string | undefined>;
+  getNameVariants: () => Promise<unknown>;
+  next: () => Promise<{ version: string } | undefined>;
+  previous: () => Promise<{ version: string } | undefined>;
+  up: (options?: MigrateOptions) => Promise<MigrationResult>;
+  down: (options?: MigrateOptions) => Promise<MigrationResult>;
+  migrateTo: (
+    version: string,
+    options?: MigrateOptions,
+  ) => Promise<MigrationResult>;
+  migrateToLatest: (options?: MigrateOptions) => Promise<MigrationResult>;
+}
+
+export type SchemaGenerator = (
+  version: string | "latest",
+  name?: string,
+) => {
+  code: string;
+  path: string;
+};
+
+export interface DatabaseAdapterCapabilities {
+  adapterName?: string;
   provider?: ORMProvider;
-  createORM(this: any, schema: any): unknown;
-  getSchemaVersion(this: any): Promise<string | undefined>;
-  generateSchema?: (
-    this: any,
-    schema: any,
-    schemaName: string,
-  ) => {
-    code: string;
-    path: string;
-  };
-  createMigrationEngine?: (this: any) => unknown;
+  createMigrator?: () => Migrator;
+  generateSchema?: SchemaGenerator;
 }
 
+export type DatabaseAdapterWithCapabilities<TContext = unknown> =
+  DatabasePlugin<TContext> & DatabaseAdapterCapabilities;
+
 export type DatabaseAdapter<TContext = unknown> =
-  | ORMDatabaseAdapter
+  | DatabaseAdapterWithCapabilities<TContext>
   | DatabasePlugin<TContext>
   | DatabasePluginFactory<TContext>;
 
@@ -59,12 +109,6 @@ export function isDatabasePlugin<TContext = unknown>(
   );
 }
 
-export function isFumaAdapter<TContext = unknown>(
-  adapter: DatabaseAdapter<TContext>,
-): adapter is ORMDatabaseAdapter {
-  return !isDatabasePluginFactory(adapter) && !isDatabasePlugin(adapter);
-}
-
 export function getSQLProvider(
   provider: ORMProvider | undefined,
 ): ORMSQLProvider | undefined {
@@ -72,7 +116,7 @@ export function getSQLProvider(
     return undefined;
   }
 
-  return sqlProviders.includes(provider as ORMSQLProvider)
+  return (sqlProviders as readonly string[]).includes(provider)
     ? (provider as ORMSQLProvider)
     : undefined;
 }

package/src/runtime.spec.ts

@@ -9,6 +9,7 @@ import type {
 import { createDatabasePlugin } from "@hot-updater/plugin-core";
 import { describe, expect, expectTypeOf, it, vi } from "vitest";
 
+import type { DatabaseAdapterCapabilities, Migrator } from "./db/types";
 import { createHotUpdater } from "./runtime";
 import { HOT_UPDATER_SERVER_VERSION } from "./version";
 
@@ -46,6 +47,55 @@ 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("requires storages to implement the runtime profile", () => {
     const database: DatabasePlugin<TestContext> = {
@@ -98,6 +148,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/runtime.ts

@@ -1,12 +1,15 @@
 import type {
+  DatabasePlugin,
   HotUpdaterContext,
   RuntimeStoragePlugin,
 } from "@hot-updater/plugin-core";
 import { assertRuntimeStoragePlugin } from "@hot-updater/plugin-core";
 
 import { createPluginDatabaseCore } from "./db/pluginCore";
+import { createSchemaReadinessChecker } from "./db/schemaReadiness";
 import {
   type DatabaseAdapter,
+  type DatabaseAdapterCapabilities,
   type DatabaseAPI,
   isDatabasePlugin,
   isDatabasePluginFactory,
@@ -61,16 +64,25 @@ export function createHotUpdater<TContext = unknown>(
     );
   }
 
-  const plugin = isDatabasePluginFactory(database) ? database() : database;
+  const capabilities = database as DatabaseAdapterCapabilities;
+  const plugin: DatabasePlugin<TContext> = isDatabasePluginFactory(database)
+    ? database()
+    : database;
+  const adapterName = capabilities.adapterName ?? plugin.name;
+  const assertSchemaReady = createSchemaReadinessChecker(
+    adapterName,
+    capabilities.createMigrator,
+  );
   const core = createPluginDatabaseCore<TContext>(
     () => plugin,
     resolveFileUrl,
     isDatabasePluginFactory(database)
       ? {
           createMutationPlugin: () => database(),
+          beforeOperation: assertSchemaReady,
           readStorageText,
         }
-      : { readStorageText },
+      : { beforeOperation: assertSchemaReady, readStorageText },
   );
 
   const internalHandler = createHandler(core.api, {

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");
+      }
+    }
+  });
+});