@hot-updater/server 1.0.0-rc.1 → 1.0.0-rc.16

package/src/db/settingsMigrator.ts

@@ -0,0 +1,152 @@
+import { HOT_UPDATER_SCHEMA_VERSION } from "../core/schema";
+import {
+  ENGINE_SCHEMA_KEY,
+  ENGINE_SCHEMA_VERSION,
+  isMissingSchemaError,
+  SETTINGS_TABLE,
+  type SchemaSettings,
+} from "../database/fence";
+import { HotUpdaterSchemaMigrationRequiredError } from "../database/fence";
+import type { SqlExecutor } from "../database/sql/sqlAdapter";
+import { quoteSql } from "../database/sql/sqlSchema";
+import { settingsStatements } from "./engineSql";
+import {
+  assertSupportedMigrationMode,
+  getEmptyMigrationResult,
+} from "./fixedMigratorShared";
+import type { MigrateOptions, MigrationResult, Migrator } from "./types";
+
+/**
+ * Every settings row by key and value alone, so a v0 layout reads too; null
+ * when the settings table is missing.
+ */
+export const readStoredSettings = async (
+  executor: SqlExecutor,
+  tablePrefix = "",
+): Promise<ReadonlyMap<string, unknown> | null> => {
+  const quote = (name: string) => quoteSql(executor.dialect, name);
+  try {
+    const { rows } = await executor.execute({
+      sql: `SELECT ${quote("key")}, ${quote("value")} FROM ${quote(tablePrefix + SETTINGS_TABLE.name)}`,
+      params: [],
+    });
+    return new Map(rows.map((row) => [String(row.key), row.value]));
+  } catch (error) {
+    if (!isMissingSchemaError(error)) throw error;
+    return null;
+  }
+};
+
+/** `schema.core`, or a v0 database's `version`. */
+export const storedSchemaVersion = (
+  stored: ReadonlyMap<string, unknown> | null,
+): string | undefined => {
+  const version = stored?.get("schema.core") ?? stored?.get("version");
+  return typeof version === "string" ? version : undefined;
+};
+
+/** A v0 or pre-engine database is recreated, never converted. */
+export const refusePreEngineDatabase = (
+  adapterName: string,
+  stored: ReadonlyMap<string, unknown>,
+): void => {
+  const version = storedSchemaVersion(stored);
+  if (version === undefined || stored.has(ENGINE_SCHEMA_KEY)) return;
+  throw new HotUpdaterSchemaMigrationRequiredError(
+    adapterName,
+    version,
+    stored.has("schema.core")
+      ? { key: ENGINE_SCHEMA_KEY, expected: ENGINE_SCHEMA_VERSION, found: null }
+      : undefined,
+  );
+};
+
+/**
+ * `hot-updater db migrate` for an ORM that applies the DDL itself (Drizzle,
+ * Prisma): it sets what the ORM cannot declare, writes the settings rows, and
+ * refuses a v0 or pre-engine database.
+ */
+export const createSettingsMigrator = (options: {
+  readonly adapterName: string;
+  readonly executor: SqlExecutor;
+  readonly settings: SchemaSettings;
+  /** How the ORM applies the tables, for the error when they are missing. */
+  readonly applyTables: string;
+  /** What the ORM cannot declare, set before the settings rows. */
+  readonly fixups?: {
+    readonly description: string;
+    readonly statements: readonly string[];
+  };
+}): Migrator => {
+  const read = () => readStoredSettings(options.executor);
+  const getVersion = async () => storedSchemaVersion(await read());
+
+  const makeResult = async (
+    migrate: MigrateOptions = {},
+  ): Promise<MigrationResult> => {
+    assertSupportedMigrationMode(migrate);
+    const stored = await read();
+    if (stored === null) {
+      throw new Error(
+        `${options.adapterName}: the Hot Updater tables are missing. Run \`hot-updater db generate\`, apply the schema with ${options.applyTables}, then migrate again.`,
+      );
+    }
+    refusePreEngineDatabase(options.adapterName, stored);
+    if (
+      migrate.updateSettings === false ||
+      Object.entries(options.settings).every(
+        ([key, value]) => stored.get(key) === value,
+      )
+    ) {
+      return getEmptyMigrationResult();
+    }
+    const fixups = options.fixups?.statements ?? [];
+    const statements = [
+      ...fixups,
+      ...settingsStatements(options.executor.dialect, options.settings),
+    ];
+    return {
+      operations: [
+        ...(fixups.length === 0
+          ? []
+          : [
+              {
+                type: "custom" as const,
+                description: options.fixups!.description,
+              },
+            ]),
+        {
+          type: "custom",
+          description: `Write the schema settings: ${Object.keys(options.settings).join(", ")}`,
+        },
+      ],
+      getSQL: () => statements.map((statement) => `${statement};`).join("\n\n"),
+      execute: async () => {
+        for (const sql of statements) {
+          await options.executor.execute({ sql, params: [] });
+        }
+      },
+    };
+  };
+
+  return {
+    getVersion,
+    getNameVariants: async () => undefined,
+    next: async () =>
+      (await getVersion()) === HOT_UPDATER_SCHEMA_VERSION
+        ? undefined
+        : { version: HOT_UPDATER_SCHEMA_VERSION },
+    previous: async () => undefined,
+    up: makeResult,
+    down: async () => {
+      throw new Error("No previous schema to migrate to.");
+    },
+    migrateTo: async (version, migrate) => {
+      if (version !== HOT_UPDATER_SCHEMA_VERSION) {
+        throw new Error(`Invalid version ${version}`);
+      }
+      return makeResult(migrate);
+    },
+    migrateToLatest: makeResult,
+  };
+};

package/src/db/types.ts

@@ -1,37 +1,15 @@
-import type { ArtifactInfo, Bundle } from "@hot-updater/core";
-import type {
-  ChannelDeleteInput,
-  ChannelDeleteResult,
-  ChannelInsertInput,
-  ChannelInsertResult,
-  ChannelRow,
-  DatabaseCommit,
-  DatabaseCommitResult,
-  DatabasePlugin as DatabasePluginContract,
-  ReleaseCatalogMutationPreflight,
-  ReleaseCatalogMutationResult,
-  ReleaseCatalogRebuildResult,
-  ReleaseCatalogRow,
-  ReleasePolicyPatch,
-  ReleaseRow,
-} from "@hot-updater/plugin-core";
+import type { EngineDatabase } from "@hot-updater/plugin-core";
 
-import type { PaginatedResult } from "../types";
+import type { SchemaSettings } from "../database/fence";
+import type { ResolvedSchema } from "../database/resolveSchema";
 
-export const sqlProviders = [
-  "sqlite",
-  "cockroachdb",
-  "mysql",
-  "postgresql",
-  "mssql",
-] as const;
+export const sqlProviders = ["sqlite", "mysql", "postgresql"] as const;
 
 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";
@@ -71,152 +49,34 @@ export interface Migrator {
   migrateToLatest: (options?: MigrateOptions) => Promise<MigrationResult>;
 }
 
+/**
+ * The tables `db migrate` and `db generate` create and the settings rows they
+ * write: the built-in ones, and each third-party plugin's the server runs.
+ */
+export interface ToolingTarget {
+  readonly schema: ResolvedSchema;
+  readonly settings: SchemaSettings;
+}
+
 export type SchemaGenerator = (
   version: string | "latest",
   name?: string,
+  target?: ToolingTarget,
 ) => {
   code: string;
   path: string;
 };
 
-export interface DatabaseAdapterCapabilities {
-  adapterName?: string;
-  provider?: ORMProvider;
-  createMigrator?: () => Migrator;
-  generateSchema?: SchemaGenerator;
-}
-
-export type DatabaseAdapterWithCapabilities = DatabasePluginContract &
-  DatabaseAdapterCapabilities;
-
-export type DatabasePlugin = DatabaseAdapterWithCapabilities;
-
-export function isDatabasePlugin(plugin: unknown): plugin is DatabasePlugin {
-  return (
-    typeof plugin === "object" &&
-    plugin !== null &&
-    "name" in plugin &&
-    typeof plugin.name === "string" &&
-    "models" in plugin &&
-    typeof plugin.models === "object" &&
-    plugin.models !== null &&
-    "bundles" in plugin.models &&
-    typeof plugin.models.bundles === "object" &&
-    plugin.models.bundles !== null &&
-    "findById" in plugin.models.bundles &&
-    typeof plugin.models.bundles.findById === "function" &&
-    "findMany" in plugin.models.bundles &&
-    typeof plugin.models.bundles.findMany === "function" &&
-    "count" in plugin.models.bundles &&
-    typeof plugin.models.bundles.count === "function" &&
-    "bundlePatches" in plugin.models &&
-    typeof plugin.models.bundlePatches === "object" &&
-    plugin.models.bundlePatches !== null &&
-    "findByBundleIds" in plugin.models.bundlePatches &&
-    typeof plugin.models.bundlePatches.findByBundleIds === "function" &&
-    "channels" in plugin.models &&
-    typeof plugin.models.channels === "object" &&
-    plugin.models.channels !== null &&
-    "insert" in plugin.models.channels &&
-    typeof plugin.models.channels.insert === "function" &&
-    "list" in plugin.models.channels &&
-    typeof plugin.models.channels.list === "function" &&
-    "delete" in plugin.models.channels &&
-    typeof plugin.models.channels.delete === "function" &&
-    "insights" in plugin.models &&
-    typeof plugin.models.insights === "object" &&
-    plugin.models.insights !== null &&
-    "append" in plugin.models.insights &&
-    typeof plugin.models.insights.append === "function" &&
-    "scan" in plugin.models.insights &&
-    typeof plugin.models.insights.scan === "function" &&
-    "apiKeys" in plugin.models &&
-    typeof plugin.models.apiKeys === "object" &&
-    plugin.models.apiKeys !== null &&
-    "create" in plugin.models.apiKeys &&
-    typeof plugin.models.apiKeys.create === "function" &&
-    "findByHash" in plugin.models.apiKeys &&
-    typeof plugin.models.apiKeys.findByHash === "function" &&
-    "list" in plugin.models.apiKeys &&
-    typeof plugin.models.apiKeys.list === "function" &&
-    "revoke" in plugin.models.apiKeys &&
-    typeof plugin.models.apiKeys.revoke === "function" &&
-    "commit" in plugin &&
-    typeof plugin.commit === "function" &&
-    (!("dispose" in plugin) ||
-      plugin.dispose === undefined ||
-      typeof plugin.dispose === "function")
-  );
+/**
+ * What `hot-updater db generate` and `db migrate` run for a provider's
+ * database, beside the database itself. Without a target they cover the
+ * built-in tables.
+ */
+export interface DatabaseTooling {
+  readonly provider?: ORMProvider;
+  readonly createMigrator?: (target?: ToolingTarget) => Migrator;
+  readonly generateSchema?: SchemaGenerator;
 }
 
-export function getSQLProvider(
-  provider: ORMProvider | undefined,
-): ORMSQLProvider | undefined {
-  if (!provider) {
-    return undefined;
-  }
-
-  return (sqlProviders as readonly string[]).includes(provider)
-    ? (provider as ORMSQLProvider)
-    : undefined;
-}
-
-export interface DatabaseAPI {
-  getBundleById(id: string): Promise<Bundle | null>;
-  getReleaseCatalog(
-    input: import("./releaseCatalog").ReleaseCatalogRequest,
-  ): Promise<import("@hot-updater/core").ReleaseCatalog | null>;
-  getArtifactInfo(
-    targetBundleId: string,
-    currentBundleId: string,
-  ): Promise<ArtifactInfo | null>;
-  getReleaseById(id: string): Promise<ReleaseRow | null>;
-  getReleasesByScope(input: {
-    readonly scopeKey: string;
-    readonly afterReleaseId?: string;
-    readonly limit: number;
-  }): Promise<readonly ReleaseRow[]>;
-  getReleases(input: {
-    readonly afterReleaseId?: string;
-    readonly beforeReleaseId?: string;
-    readonly bundleId?: string;
-    readonly channelId?: string;
-    readonly enabled?: boolean;
-    readonly platform?: "ios" | "android";
-    readonly targetAppVersion?: string;
-    readonly limit: number;
-  }): Promise<readonly ReleaseRow[]>;
-  getReleaseCatalogByScopeKey(
-    scopeKey: string,
-  ): Promise<ReleaseCatalogRow | null>;
-  getReleaseCatalogs(input: {
-    readonly afterScopeKey?: string;
-    readonly limit: number;
-  }): Promise<readonly ReleaseCatalogRow[]>;
-  updateReleasePolicy(input: {
-    readonly expectedRevision?: number;
-    readonly patch: ReleasePolicyPatch;
-    readonly releaseId: string;
-  }): Promise<ReleaseCatalogMutationResult>;
-  preflightReleasePolicy(input: {
-    readonly expectedRevision?: number;
-    readonly patch: ReleasePolicyPatch;
-    readonly releaseId: string;
-  }): Promise<ReleaseCatalogMutationPreflight>;
-  deleteRelease(input: {
-    readonly expectedRevision?: number;
-    readonly releaseId: string;
-  }): Promise<ReleaseCatalogMutationResult>;
-  rebuildReleaseCatalog(scopeKey: string): Promise<ReleaseCatalogRebuildResult>;
-  commitDatabase(input: DatabaseCommit): Promise<DatabaseCommitResult>;
-  getChannels(): Promise<readonly ChannelRow[]>;
-  insertChannel(input: ChannelInsertInput): Promise<ChannelInsertResult>;
-  deleteChannel(input: ChannelDeleteInput): Promise<ChannelDeleteResult>;
-  getBundles(
-    options: import("@hot-updater/plugin-core").DatabaseBundleQueryOptions,
-  ): Promise<PaginatedResult>;
-  insertBundle(bundle: Bundle): Promise<void>;
-  insertBundles(bundles: readonly Bundle[]): Promise<void>;
-  updateBundleById(bundleId: string, newBundle: Partial<Bundle>): Promise<void>;
-  deleteBundleById(bundleId: string): Promise<void>;
-}
+/** A provider's database on the storage engine, with its tooling. */
+export type ToolingDatabase = EngineDatabase & DatabaseTooling;