@hot-updater/server 1.0.0-rc.18 → 1.0.0-rc.21

package/src/db/engineSql.spec.ts

@@ -1,130 +0,0 @@
-import { DatabaseSync } from "node:sqlite";
-
-import { PGlite } from "@electric-sql/pglite";
-import { afterAll, describe, expect, it } from "vitest";
-
-import { createBundleFixture } from "../../../test-utils/src/databaseTestFixtures";
-import { createInProcessCoreApi } from "../core/api";
-import { createSqlAdapter } from "../database/sql/sqlAdapter";
-import {
-  createTableStatements,
-  sqlTableShapes,
-  type SqlTableShape,
-} from "../database/sql/sqlSchema";
-import {
-  pgliteExecutor,
-  sqliteExecutor,
-} from "../database/sql/sqlTestExecutors";
-import { apiKeys } from "../plugins/api-keys";
-import { insights } from "../plugins/insights";
-import { createEngineDatabase, toolingTargetOf } from "./coreDatabase";
-import { generateEngineSql } from "./engineSql";
-
-/** Core's tables and the Insights and API keys plugins'. */
-const target = toolingTargetOf([insights(), apiKeys()]);
-
-const sql = (dialect: "postgresql" | "mysql" | "sqlite") =>
-  generateEngineSql(dialect, target.schema, target.settings);
-
-describe("the shared SQL schema", () => {
-  it("defaults engine columns, has no foreign keys, and writes the settings last", () => {
-    const postgres = sql("postgresql");
-    expect(
-      postgres.find((statement) => statement.includes('"bundles" (')),
-    ).toContain(
-      '"_refs_releases_bundle_id" bigint NOT NULL DEFAULT 0, "_v" bigint NOT NULL DEFAULT 0',
-    );
-    for (const dialect of ["postgresql", "mysql", "sqlite"] as const) {
-      expect(
-        sql(dialect).some(
-          (statement) =>
-            statement.includes("FOREIGN KEY") ||
-            statement.startsWith("ALTER TABLE"),
-        ),
-      ).toBe(false);
-    }
-    expect(
-      postgres
-        .slice(-4)
-        .every((statement) =>
-          statement.startsWith('INSERT INTO "private_hot_updater_settings"'),
-        ),
-    ).toBe(true);
-    expect(sql("mysql").at(-1)).toContain("ON DUPLICATE KEY UPDATE");
-  });
-
-  it("describes each table as its DDL creates it, for ORM schema generators", () => {
-    const tables = target.schema.tables;
-    const names = (shapes: readonly SqlTableShape[]): string[] =>
-      shapes.flatMap((shape) => [
-        shape.name,
-        ...names(
-          shape.indexes.flatMap((index) =>
-            index.kind === "table" ? [index.table] : [],
-          ),
-        ),
-      ]);
-    const created = createTableStatements("postgresql", tables).flatMap(
-      (statement) =>
-        statement.match(/^CREATE TABLE IF NOT EXISTS "(\w+)"/u)?.[1] ?? [],
-    );
-    const shapes = sqlTableShapes("postgresql", tables);
-    expect(names(shapes)).toEqual(created);
-    expect(created.some((name) => name.includes("__"))).toBe(true);
-    expect(
-      shapes
-        .find((shape) => shape.name === "bundles")
-        ?.columns.find((column) => column.name === "_v"),
-    ).toEqual({ name: "_v", type: "bigint", notNull: true, default: 0 });
-  });
-
-  const pglite = new PGlite();
-  afterAll(() => pglite.close());
-
-  it("runs twice on PostgreSQL and passes the fence; the engine keeps references", async () => {
-    for (let run = 0; run < 2; run += 1) {
-      await pglite.exec(sql("postgresql").join(";\n"));
-    }
-    const core = createInProcessCoreApi(
-      createEngineDatabase({
-        name: "pglite",
-        adapter: createSqlAdapter({ executor: pgliteExecutor(pglite) }),
-      }).adapter,
-    );
-    const bundle = createBundleFixture("1");
-    await core.deploy([
-      {
-        bundle,
-        release: {
-          channel: "production",
-          enabled: true,
-          fingerprintHash: null,
-          message: null,
-          shouldForceUpdate: false,
-          targetAppVersion: "1.0.0",
-        },
-      },
-    ]);
-
-    await expect(core.deleteBundles([bundle.id])).rejects.toThrow(
-      "still referenced",
-    );
-    const { rows } = await pglite.query<{ count: number }>(
-      "SELECT count(*)::int AS count FROM information_schema.table_constraints WHERE constraint_type = 'FOREIGN KEY'",
-    );
-    expect(rows[0]!.count).toBe(0);
-  });
-
-  it("runs on SQLite and passes the fence", async () => {
-    const db = new DatabaseSync(":memory:");
-    for (const statement of sql("sqlite")) db.exec(statement);
-    const core = createInProcessCoreApi(
-      createEngineDatabase({
-        name: "sqlite",
-        adapter: createSqlAdapter({ executor: sqliteExecutor(db) }),
-      }).adapter,
-    );
-    await expect(core.listChannels()).resolves.toEqual([]);
-    db.close();
-  });
-});

package/src/db/engineSql.ts

@@ -1,48 +0,0 @@
-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

@@ -1,116 +0,0 @@
-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,17 +0,0 @@
-import { HOT_UPDATER_SCHEMA_VERSION } from "../core/schema";
-import type { MigrateOptions, MigrationResult } from "./types";
-
-export const getEmptyMigrationResult = (): MigrationResult => ({
-  operations: [],
-  execute: async () => {},
-  getSQL: () => "",
-});
-
-export const assertSupportedMigrationMode = (options: MigrateOptions): void => {
-  if (options.mode === "from-database") {
-    throw new Error("Hot Updater migrations support only mode: 'from-schema'.");
-  }
-};
-
-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}.`;