@hot-updater/server 0.33.2 → 0.35.0

package/src/db/index.ts

@@ -1,118 +1,47 @@
-import type {
-  DatabasePlugin,
-  HotUpdaterContext,
-  RuntimeStoragePlugin,
-} from "@hot-updater/plugin-core";
-import { assertRuntimeStoragePlugin } from "@hot-updater/plugin-core";
-
-export * from "./createBundleDiff";
-import { createHandler, type HandlerRoutes } from "../handler";
-import { normalizeBasePath } from "../route";
-import { createStorageAccess } from "../storageAccess";
-import {
-  createOrmDatabaseCore,
-  type HotUpdaterClient,
-  type Migrator,
-} from "./ormCore";
-import { createPluginDatabaseCore } from "./pluginCore";
 import {
-  type DatabaseAdapter,
-  type DatabaseAPI,
-  isDatabasePlugin,
-  isDatabasePluginFactory,
-  type StoragePluginFactory,
-} from "./types";
+  getHotUpdaterCoreMetadata,
+  type RuntimeHotUpdaterAPI,
+} from "../createHotUpdaterCore";
+import { generateSchemaFromHotUpdaterSchema } from "./schemaGenerators";
+import { type Migrator, type SchemaGenerator } from "./types";
 
-export type { HotUpdaterClient, Migrator } from "./ormCore";
-export { HotUpdaterDB } from "./ormCore";
+export * from "./createBundleDiff";
+export type { Migrator, SchemaGenerator } from "./types";
+export { HotUpdaterSchemaMigrationRequiredError } from "./schemaReadiness";
 export { HOT_UPDATER_SERVER_VERSION } from "../version";
 
-export type HotUpdaterAPI<TContext = unknown> = DatabaseAPI<TContext> & {
-  basePath: string;
-  handler: (
-    request: Request,
-    context?: HotUpdaterContext<TContext>,
-  ) => Promise<Response>;
-  adapterName: string;
-  createMigrator: () => Migrator;
-  generateSchema: HotUpdaterClient["generateSchema"];
+export type HotUpdaterDBTarget = {
+  readonly adapterName: string;
 };
 
-export interface CreateHotUpdaterOptions<TContext = unknown> {
-  database: DatabaseAdapter<TContext>;
-  /**
-   * Storage plugins for handling file uploads and downloads.
-   */
-  storages?: (
-    | RuntimeStoragePlugin<TContext>
-    | StoragePluginFactory<TContext>
-  )[];
-  /**
-   * @deprecated Use `storages` instead. This field will be removed in a future version.
-   */
-  storagePlugins?: (
-    | RuntimeStoragePlugin<TContext>
-    | StoragePluginFactory<TContext>
-  )[];
-  basePath?: string;
-  cwd?: string;
-  routes?: HandlerRoutes;
-}
-
-export function createHotUpdater<TContext = unknown>(
-  options: CreateHotUpdaterOptions<TContext>,
-): HotUpdaterAPI<TContext> {
-  const basePath = normalizeBasePath(options.basePath ?? "/api");
-
-  // Initialize storage plugins - call factories if they are functions
-  const storagePlugins = (options.storages ?? options.storagePlugins ?? []).map(
-    (plugin) => {
-      const storagePlugin = typeof plugin === "function" ? plugin() : plugin;
-      assertRuntimeStoragePlugin(storagePlugin);
-      return storagePlugin;
-    },
+const getDBMetadata = (hotUpdater: HotUpdaterDBTarget) => {
+  const metadata = getHotUpdaterCoreMetadata(
+    hotUpdater as RuntimeHotUpdaterAPI,
   );
-  const { readStorageText, resolveFileUrl } =
-    createStorageAccess(storagePlugins);
-
-  const database = options.database;
-
-  const core =
-    isDatabasePluginFactory(database) || isDatabasePlugin(database)
-      ? (() => {
-          const plugin: DatabasePlugin<TContext> = isDatabasePluginFactory(
-            database,
-          )
-            ? database()
-            : database;
+  if (!metadata) {
+    throw new Error(
+      "Database tooling requires a hotUpdater instance created by @hot-updater/server.",
+    );
+  }
+  return metadata;
+};
 
-          return createPluginDatabaseCore<TContext>(
-            () => plugin,
-            resolveFileUrl,
-            isDatabasePluginFactory(database)
-              ? {
-                  createMutationPlugin: () => database(),
-                  readStorageText,
-                }
-              : { readStorageText },
-          );
-        })()
-      : createOrmDatabaseCore<TContext>({
-          database,
-          readStorageText,
-          resolveFileUrl,
-        });
+export function createMigrator(hotUpdater: HotUpdaterDBTarget): Migrator {
+  const { adapterCapabilities, core } = getDBMetadata(hotUpdater);
+  return (adapterCapabilities.createMigrator ?? core.createMigrator)();
+}
 
-  const api = {
-    basePath,
-    adapterName: core.adapterName,
-    createMigrator: core.createMigrator,
-    generateSchema: core.generateSchema,
-    handler: createHandler(core.api, {
-      basePath,
-      routes: options.routes,
-    }),
-  };
-  Object.defineProperties(api, Object.getOwnPropertyDescriptors(core.api));
-  return api as HotUpdaterAPI<TContext>;
+export function generateSchema(
+  hotUpdater: HotUpdaterDBTarget,
+  ...args: Parameters<SchemaGenerator>
+): ReturnType<SchemaGenerator> {
+  const { adapterCapabilities, core } = getDBMetadata(hotUpdater);
+  const schemaGenerator =
+    adapterCapabilities.generateSchema ?? core.generateSchema;
+  return generateSchemaFromHotUpdaterSchema(
+    hotUpdater.adapterName,
+    adapterCapabilities.provider,
+    args[0],
+    schemaGenerator(...args),
+  );
 }

package/src/db/pluginCore.spec.ts

@@ -4,7 +4,7 @@ import type {
   DatabasePlugin,
   RequestEnvContext,
 } from "@hot-updater/plugin-core";
-import { createDatabasePluginGetUpdateInfo } from "@hot-updater/plugin-core";
+import { resolveUpdateInfoFromBundles } from "@hot-updater/plugin-core";
 import { describe, expect, it, vi } from "vitest";
 
 import { createPluginDatabaseCore } from "./pluginCore";
@@ -449,11 +449,14 @@ describe("createPluginDatabaseCore", () => {
         throw new Error("unexpected provider bundle reread");
       },
     );
-    const getUpdateInfo = createDatabasePluginGetUpdateInfo<TestContext>({
-      getBundlesByFingerprint: async () => [],
-      getBundlesByTargetAppVersions: async () => [targetBundle],
-      listTargetAppVersions: async () => ["1.0.0"],
-    });
+    const getUpdateInfo: NonNullable<
+      DatabasePlugin<TestContext>["getUpdateInfo"]
+    > = async (args, context) =>
+      resolveUpdateInfoFromBundles({
+        args,
+        bundles: [targetBundle],
+        context,
+      });
     const plugin: DatabasePlugin<TestContext> = {
       name: "seeded-fast-path-plugin",
       async appendBundle() {},
@@ -547,11 +550,14 @@ describe("createPluginDatabaseCore", () => {
         throw new Error("unexpected provider current bundle reread");
       },
     );
-    const getUpdateInfo = createDatabasePluginGetUpdateInfo<TestContext>({
-      getBundlesByFingerprint: async () => [],
-      getBundlesByTargetAppVersions: async () => [targetBundle],
-      listTargetAppVersions: async () => ["1.0.0"],
-    });
+    const getUpdateInfo: NonNullable<
+      DatabasePlugin<TestContext>["getUpdateInfo"]
+    > = async (args, context) =>
+      resolveUpdateInfoFromBundles({
+        args,
+        bundles: [targetBundle],
+        context,
+      });
     const plugin: DatabasePlugin<TestContext> = {
       name: "seeded-current-miss-plugin",
       async appendBundle() {},

package/src/db/pluginCore.ts

@@ -113,6 +113,7 @@ export function createPluginDatabaseCore<TContext = unknown>(
     cleanupMutationPlugin?: (
       plugin: DatabasePlugin<TContext>,
     ) => Promise<void> | void;
+    beforeOperation?: () => Promise<void>;
     readStorageText?: (
       storageUri: string,
       context?: HotUpdaterContext<TContext>,
@@ -124,16 +125,17 @@ export function createPluginDatabaseCore<TContext = unknown>(
   createMigrator: () => never;
   generateSchema: () => never;
 } {
+  const coreOptions = options;
   const runWithMutationPlugin = async <T>(
     operation: (plugin: DatabasePlugin<TContext>) => Promise<T>,
   ): Promise<T> => {
-    const plugin = options?.createMutationPlugin?.() ?? getPlugin();
+    const plugin = coreOptions?.createMutationPlugin?.() ?? getPlugin();
 
     try {
       return await operation(plugin);
     } finally {
-      if (options?.createMutationPlugin) {
-        await options.cleanupMutationPlugin?.(plugin);
+      if (coreOptions?.createMutationPlugin) {
+        await coreOptions.cleanupMutationPlugin?.(plugin);
       }
     }
   };
@@ -278,6 +280,7 @@ export function createPluginDatabaseCore<TContext = unknown>(
       id: string,
       context?: HotUpdaterContext<TContext>,
     ): Promise<Bundle | null> {
+      await coreOptions?.beforeOperation?.();
       return getPlugin().getBundleById(id, context);
     },
 
@@ -285,6 +288,7 @@ export function createPluginDatabaseCore<TContext = unknown>(
       args: GetBundlesArgs,
       context?: HotUpdaterContext<TContext>,
     ): Promise<UpdateInfo | null> {
+      await coreOptions?.beforeOperation?.();
       const plugin = getPlugin();
       const directGetUpdateInfo = plugin.getUpdateInfo;
       if (directGetUpdateInfo) {
@@ -350,7 +354,7 @@ export function createPluginDatabaseCore<TContext = unknown>(
       }
       const { storageUri, ...rest } = info;
 
-      const readStorageText = options?.readStorageText;
+      const readStorageText = coreOptions?.readStorageText;
       if (info.id === NIL_UUID || !readStorageText) {
         const fileUrl = await resolveFileUrl(storageUri ?? null, context);
         const baseResponse: AppUpdateAvailableInfo = { ...rest, fileUrl };
@@ -400,10 +404,12 @@ export function createPluginDatabaseCore<TContext = unknown>(
     async getChannels(
       context?: HotUpdaterContext<TContext>,
     ): Promise<string[]> {
+      await coreOptions?.beforeOperation?.();
       return getPlugin().getChannels(context);
     },
 
     async getBundles(options, context?: HotUpdaterContext<TContext>) {
+      await coreOptions?.beforeOperation?.();
       return getPlugin().getBundles(options, context);
     },
 
@@ -411,6 +417,7 @@ export function createPluginDatabaseCore<TContext = unknown>(
       bundle: Bundle,
       context?: HotUpdaterContext<TContext>,
     ): Promise<void> {
+      await coreOptions?.beforeOperation?.();
       assertBundlePersistenceConstraints(bundle);
       await runWithMutationPlugin(async (plugin) => {
         await plugin.appendBundle(bundle, context);
@@ -423,6 +430,7 @@ export function createPluginDatabaseCore<TContext = unknown>(
       newBundle: Partial<Bundle>,
       context?: HotUpdaterContext<TContext>,
     ): Promise<void> {
+      await coreOptions?.beforeOperation?.();
       await runWithMutationPlugin(async (plugin) => {
         const current = await plugin.getBundleById(bundleId, context);
         if (!current) {
@@ -438,6 +446,7 @@ export function createPluginDatabaseCore<TContext = unknown>(
       bundleId: string,
       context?: HotUpdaterContext<TContext>,
     ): Promise<void> {
+      await coreOptions?.beforeOperation?.();
       await runWithMutationPlugin(async (plugin) => {
         const bundle = await plugin.getBundleById(bundleId, context);
         if (!bundle) {
@@ -454,12 +463,12 @@ export function createPluginDatabaseCore<TContext = unknown>(
     adapterName: getPlugin().name,
     createMigrator: () => {
       throw new Error(
-        "createMigrator is only available for Kysely/Prisma/Drizzle database adapters.",
+        "createMigrator is only available for Kysely/MongoDB database adapters.",
       );
     },
     generateSchema: () => {
       throw new Error(
-        "generateSchema is only available for Kysely/Prisma/Drizzle database adapters.",
+        "generateSchema is only available for Drizzle/Prisma database adapters.",
       );
     },
   };

package/src/db/schema/definitions.ts

@@ -0,0 +1 @@
+export * from "../../schema";

package/src/db/schema/mongodb.ts

@@ -0,0 +1,26 @@
+import type { MigrationOperation } from "../types";
+import { hotUpdaterSchema, schemaIndexAppliesToProvider } from "./registry";
+import { hotUpdaterCreateTableOperations } from "./sql";
+
+export const createMongoMigrationOperations = (
+  settingsOperation?: MigrationOperation,
+): MigrationOperation[] => [
+  ...hotUpdaterCreateTableOperations,
+  {
+    type: "custom",
+    sql: "create index bundles_id_idx on bundles(id)",
+  },
+  ...hotUpdaterSchema.tables.flatMap((table) =>
+    (table.indexes ?? [])
+      .filter((index) => schemaIndexAppliesToProvider(index, "mongodb"))
+      .map(
+        (index): MigrationOperation => ({
+          type: "custom",
+          sql: `create index ${index.name} on ${table.ormName}(${index.columns.join(
+            ", ",
+          )})`,
+        }),
+      ),
+  ),
+  ...(settingsOperation ? [settingsOperation] : []),
+];

package/src/db/schema/registry.ts

@@ -0,0 +1,55 @@
+import { hotUpdaterSchemaVersions } from "../../schema";
+import type {
+  HotUpdaterColumnSchema,
+  HotUpdaterIndexSchema,
+  HotUpdaterTableSchema,
+  HotUpdaterVersionedSchema,
+} from "../../schema/types";
+import type { ORMProvider } from "../types";
+
+export { hotUpdaterSchemaVersions } from "../../schema";
+
+export const hotUpdaterSchema =
+  hotUpdaterSchemaVersions[hotUpdaterSchemaVersions.length - 1]!;
+
+export const getSchemaVersionIndex = (version: string): number =>
+  hotUpdaterSchemaVersions.findIndex((schema) => schema.version === version);
+
+export const getHotUpdaterSchemaVersion = (
+  version: string,
+): HotUpdaterVersionedSchema => {
+  const schema = hotUpdaterSchemaVersions.find(
+    (item) => item.version === version,
+  );
+  if (!schema)
+    throw new Error(`Unsupported Hot Updater schema version: ${version}`);
+  return schema;
+};
+
+export const getSchemaTable = (name: string): HotUpdaterTableSchema => {
+  const table = hotUpdaterSchema.tables.find((item) => item.ormName === name);
+  if (!table) throw new Error(`Unknown Hot Updater schema table: ${name}`);
+  return table;
+};
+
+export const getSchemaColumn = (
+  table: HotUpdaterTableSchema,
+  name: string,
+): HotUpdaterColumnSchema => {
+  const column = table.columns.find((item) => item.ormName === name);
+  if (!column) {
+    throw new Error(
+      `Unknown Hot Updater schema column: ${table.ormName}.${name}`,
+    );
+  }
+  return column;
+};
+
+export const hotUpdaterDataTables = hotUpdaterSchema.tables.filter(
+  (table) => !table.internal,
+);
+
+export const schemaIndexAppliesToProvider = (
+  index: HotUpdaterIndexSchema,
+  provider: ORMProvider,
+): boolean => !index.providers || index.providers.includes(provider);

package/src/db/schema/sql.ts

@@ -0,0 +1,200 @@
+import {
+  HOT_UPDATER_SETTINGS_TABLE,
+  type HotUpdaterCheckSchema,
+  type HotUpdaterColumnSchema,
+  type HotUpdaterColumnType,
+  type HotUpdaterForeignKeySchema,
+  type HotUpdaterTableSchema,
+} from "../../schema/types";
+import type {
+  MigrationOperation,
+  ORMSQLProvider,
+  RelationMode,
+} from "../types";
+import {
+  getSchemaColumn,
+  hotUpdaterDataTables,
+  hotUpdaterSchema,
+  schemaIndexAppliesToProvider,
+} from "./registry";
+
+export const hotUpdaterCreateTableOperations: MigrationOperation[] =
+  hotUpdaterDataTables.map((table) => ({
+    type: "create-table",
+    value: {
+      ormName: table.ormName,
+      columns: Object.fromEntries(
+        table.columns.map((column) => [
+          column.ormName,
+          { ormName: column.ormName, type: column.type },
+        ]),
+      ),
+    },
+  }));
+
+export const getSqlType = (
+  type: HotUpdaterColumnType,
+  provider: ORMSQLProvider,
+): string => {
+  if (provider === "sqlite") {
+    if (type === "bool" || type === "integer") return "integer";
+    return "text";
+  }
+  if (provider === "mysql") {
+    if (type === "uuid") return "char(36)";
+    if (type === "bool") return "boolean";
+    if (type === "integer") return "integer";
+    if (type === "json") return "json";
+    if (type.startsWith("varchar")) return type;
+    return "text";
+  }
+  if (type === "uuid") return "uuid";
+  if (type === "bool") return "boolean";
+  if (type === "integer") return "integer";
+  if (type === "json") return "json";
+  if (type.startsWith("varchar")) return type;
+  return "text";
+};
+
+const sqlStringLiteral = (value: string): string =>
+  `'${value.replaceAll("'", "''")}'`;
+
+const sqlDefaultClause = (
+  column: HotUpdaterColumnSchema,
+  provider: ORMSQLProvider,
+): string => {
+  const value = column.default;
+  if (!value) return "";
+  if (
+    provider === "mysql" &&
+    (column.type === "json" || column.type === "string")
+  ) {
+    return "";
+  }
+  if (value.type === "json") {
+    const json = sqlStringLiteral(JSON.stringify(value.value));
+    return provider === "postgresql" || provider === "cockroachdb"
+      ? ` default ${json}::json`
+      : ` default ${json}`;
+  }
+  if (typeof value.value === "string") {
+    return ` default ${sqlStringLiteral(value.value)}`;
+  }
+  return ` default ${String(value.value)}`;
+};
+
+const sqlColumnName = (
+  table: HotUpdaterTableSchema,
+  column: HotUpdaterColumnSchema,
+  provider: ORMSQLProvider,
+): string =>
+  table.ormName === HOT_UPDATER_SETTINGS_TABLE &&
+  column.ormName === "key" &&
+  provider === "mysql"
+    ? "`key`"
+    : column.ormName;
+
+export const sqlColumnDefinition = (
+  table: HotUpdaterTableSchema,
+  column: HotUpdaterColumnSchema,
+  provider: ORMSQLProvider,
+): string => {
+  const constraints = [
+    column.primaryKey ? "primary key" : undefined,
+    column.nullable ? undefined : "not null",
+  ].filter(Boolean);
+  return (
+    [
+      sqlColumnName(table, column, provider),
+      getSqlType(column.type, provider),
+      ...constraints,
+    ].join(" ") + sqlDefaultClause(column, provider)
+  );
+};
+
+const sqlIndexColumn = (
+  table: HotUpdaterTableSchema,
+  columnName: string,
+  provider: ORMSQLProvider,
+): string => {
+  const column = getSchemaColumn(table, columnName);
+  return provider === "mysql" && column.type === "string"
+    ? `${columnName}(255)`
+    : columnName;
+};
+
+export const createIndexSql = (
+  table: HotUpdaterTableSchema,
+  index: { readonly name: string; readonly columns: readonly string[] },
+  provider: ORMSQLProvider,
+): string =>
+  `create index ${index.name} on ${table.ormName}(${index.columns
+    .map((column) => sqlIndexColumn(table, column, provider))
+    .join(", ")})`;
+
+export const createForeignKeySql = (
+  table: HotUpdaterTableSchema,
+  foreignKey: HotUpdaterForeignKeySchema,
+): string =>
+  `alter table ${table.ormName} add constraint ${foreignKey.name} foreign key (${foreignKey.columns.join(", ")}) references ${foreignKey.referencedTable}(${foreignKey.referencedColumns.join(", ")}) on update ${foreignKey.onUpdate} on delete ${foreignKey.onDelete}`;
+
+export const createCheckSql = (
+  table: HotUpdaterTableSchema,
+  check: HotUpdaterCheckSchema,
+): string =>
+  `alter table ${table.ormName} add constraint ${check.name} check (${check.expression})`;
+
+const inlineSqlChecks = (
+  table: HotUpdaterTableSchema,
+  provider: ORMSQLProvider,
+): string[] =>
+  provider === "sqlite"
+    ? (table.checks ?? [])
+        .filter((check) => check.sqliteInline)
+        .map((check) => `constraint ${check.name} check (${check.expression})`)
+    : [];
+
+export const createTableStatement = (
+  table: HotUpdaterTableSchema,
+  provider: ORMSQLProvider,
+): string => {
+  const lines = [
+    ...table.columns.map((column) =>
+      sqlColumnDefinition(table, column, provider),
+    ),
+    ...inlineSqlChecks(table, provider),
+  ];
+  return `create table if not exists ${table.ormName} (\n${lines.join(",\n")}\n)`;
+};
+
+export const createForeignKeySqlStatements = (
+  provider: ORMSQLProvider,
+  relationMode: RelationMode = "foreign-keys",
+): readonly string[] => {
+  if (relationMode !== "foreign-keys" || provider === "sqlite") return [];
+  return hotUpdaterSchema.tables.flatMap((table) =>
+    (table.foreignKeys ?? []).map((foreignKey) =>
+      createForeignKeySql(table, foreignKey),
+    ),
+  );
+};
+
+export const createTableSql = (
+  provider: ORMSQLProvider,
+  relationMode: RelationMode = "foreign-keys",
+): readonly string[] => [
+  ...hotUpdaterSchema.tables.map((table) =>
+    createTableStatement(table, provider),
+  ),
+  ...hotUpdaterSchema.tables.flatMap((table) =>
+    (table.indexes ?? [])
+      .filter((index) => schemaIndexAppliesToProvider(index, provider))
+      .map((index) => createIndexSql(table, index, provider)),
+  ),
+  ...(provider === "sqlite"
+    ? []
+    : hotUpdaterSchema.tables.flatMap((table) =>
+        (table.checks ?? []).map((check) => createCheckSql(table, check)),
+      )),
+  ...createForeignKeySqlStatements(provider, relationMode),
+];