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

package/src/db/engineSql.ts

@@ -0,0 +1,48 @@
+import { SETTINGS_TABLE, type SchemaSettings } from "../database/fence";
+import type { ResolvedSchema } from "../database/resolveSchema";
+import {
+  createTableStatements,
+  quoteSql,
+  type SqlDialect,
+} from "../database/sql/sqlSchema";
+
+export interface EngineSqlOptions {
+  readonly tablePrefix?: string;
+}
+
+const literal = (text: string) => `'${text.replaceAll("'", "''")}'`;
+
+/** Upserts of the settings rows the fence reads. */
+export const settingsStatements = (
+  dialect: SqlDialect,
+  settings: SchemaSettings,
+  tablePrefix = "",
+): string[] => {
+  const quote = (name: string) => quoteSql(dialect, name);
+  const [key, value, version] = ["key", "value", "_v"].map(quote);
+  return Object.entries(settings).map(([name, text]) => {
+    const insert = `INSERT INTO ${quote(tablePrefix + SETTINGS_TABLE.name)} (${key}, ${value}, ${version}) VALUES (${literal(name)}, ${literal(text)}, 0)`;
+    return dialect === "mysql"
+      ? `${insert} ON DUPLICATE KEY UPDATE ${value} = VALUES(${value})`
+      : `${insert} ON CONFLICT (${key}) DO UPDATE SET ${value} = excluded.${value}`;
+  });
+};
+
+/**
+ * A resolved schema as SQL: its tables and indexes, then the settings rows
+ * last, so the fence passes only once everything exists. There are no
+ * database foreign keys: the engine keeps references itself.
+ */
+export const generateEngineSql = (
+  dialect: SqlDialect,
+  schema: ResolvedSchema,
+  settings: SchemaSettings,
+  options: EngineSqlOptions = {},
+): string[] => [
+  ...createTableStatements(
+    dialect,
+    [...schema.tables, SETTINGS_TABLE],
+    options.tablePrefix,
+  ),
+  ...settingsStatements(dialect, settings, options.tablePrefix),
+];

package/src/db/engineSqlMigrator.ts

@@ -0,0 +1,116 @@
+import { HOT_UPDATER_SCHEMA_VERSION } from "../core/schema";
+import type { SchemaSettings } from "../database/fence";
+import type { ResolvedSchema } from "../database/resolveSchema";
+import type { SqlExecutor } from "../database/sql/sqlAdapter";
+import { generateEngineSql, type EngineSqlOptions } from "./engineSql";
+import {
+  assertSupportedMigrationMode,
+  getEmptyMigrationResult,
+} from "./fixedMigratorShared";
+import {
+  readStoredSettings,
+  refusePreEngineDatabase,
+  storedSchemaVersion,
+} from "./settingsMigrator";
+import type { MigrateOptions, MigrationResult, Migrator } from "./types";
+
+export interface EngineSqlMigratorOptions extends EngineSqlOptions {
+  readonly adapterName: string;
+  readonly executor: SqlExecutor;
+  readonly schema: ResolvedSchema;
+  readonly settings: SchemaSettings;
+}
+
+/** Runs the statements in one transaction where the dialect's DDL is transactional. */
+const run = async (executor: SqlExecutor, statements: readonly string[]) => {
+  const each = async (connection: Pick<SqlExecutor, "execute">) => {
+    for (const sql of statements) await connection.execute({ sql, params: [] });
+  };
+  await (executor.dialect === "mysql"
+    ? each(executor)
+    : executor.transaction(each));
+};
+
+/**
+ * `hot-updater db migrate` and `db generate` for an SQL provider on the
+ * engine: the generated SQL schema, applied when a settings row is missing or
+ * different, and refused on a database from before the engine.
+ */
+export const createEngineSqlMigrator = (
+  options: EngineSqlMigratorOptions,
+): Migrator => {
+  /** No settings table yet reads as an empty database. */
+  const read = async () =>
+    (await readStoredSettings(options.executor, options.tablePrefix)) ??
+    new Map<string, unknown>();
+  const getVersion = async () => storedSchemaVersion(await read());
+
+  const makeResult = async (
+    migrate: MigrateOptions = {},
+  ): Promise<MigrationResult> => {
+    assertSupportedMigrationMode(migrate);
+    const stored = await read();
+    // A database from before the engine is recreated, never converted.
+    refusePreEngineDatabase(options.adapterName, stored);
+    if (
+      Object.entries(options.settings).every(
+        ([key, value]) => stored.get(key) === value,
+      )
+    ) {
+      return getEmptyMigrationResult();
+    }
+    const statements = generateEngineSql(
+      options.executor.dialect,
+      options.schema,
+      options.settings,
+      options,
+    );
+    return {
+      operations: [
+        ...options.schema.tables.map((table) => ({
+          type: "create-table" as const,
+          value: {
+            ormName: table.name,
+            columns: Object.fromEntries(
+              table.columns.map((column) => [
+                column.name,
+                { ormName: column.name, type: column.type },
+              ]),
+            ),
+          },
+        })),
+        ...(migrate.updateSettings === false
+          ? []
+          : [
+              {
+                type: "custom" as const,
+                description: `Write the schema settings: ${Object.keys(options.settings).join(", ")}`,
+              },
+            ]),
+      ],
+      getSQL: () => statements.map((statement) => `${statement};`).join("\n\n"),
+      execute: () => run(options.executor, statements),
+    };
+  };
+
+  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/fixedMigratorShared.ts

@@ -1,4 +1,4 @@
-import { HOT_UPDATER_SCHEMA_VERSION } from "../schema/types";
+import { HOT_UPDATER_SCHEMA_VERSION } from "../core/schema";
 import type { MigrateOptions, MigrationResult } from "./types";
 
 export const getEmptyMigrationResult = (): MigrationResult => ({
@@ -15,22 +15,3 @@ export const assertSupportedMigrationMode = (options: MigrateOptions): void => {
 
 export const unsupportedSchemaUpgradeMessage = (version: string): string =>
   `Hot Updater v1 cannot migrate schema ${version} in place. Create a new empty database and run migrate or generate against schema ${HOT_UPDATER_SCHEMA_VERSION}.`;
-
-export const assertCurrentOrEmptySchemaVersion = (
-  currentVersion: string | undefined,
-): void => {
-  if (
-    currentVersion !== undefined &&
-    currentVersion !== HOT_UPDATER_SCHEMA_VERSION
-  ) {
-    throw new Error(unsupportedSchemaUpgradeMessage(currentVersion));
-  }
-};
-
-export const inferLegacyCoreSchemaVersion = (
-  legacyVersion: string | undefined,
-): string | undefined => legacyVersion;
-
-export const isCurrentSchemaVersion = (
-  currentVersion: string | undefined,
-): boolean => currentVersion === HOT_UPDATER_SCHEMA_VERSION;