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

package/src/db/schemaGenerators.ts

@@ -17,6 +17,9 @@ import { getSQLProvider } from "./types";
 
 const literal = (value: string): string => JSON.stringify(value);
 
+const varcharLength = (type: HotUpdaterColumnType): number =>
+  Number(type.slice("varchar(".length, -1));
+
 const toPascalCase = (value: string): string =>
   value
     .split("_")
@@ -27,11 +30,16 @@ const toPascalCase = (value: string): string =>
 const prismaDb = (type: HotUpdaterColumnType, provider: ORMProvider) => {
   if (provider === "postgresql") {
     if (type === "uuid") return " @db.Uuid";
-    if (type.startsWith("varchar")) return " @db.VarChar(255)";
+    if (type.startsWith("varchar")) {
+      return ` @db.VarChar(${varcharLength(type)})`;
+    }
   }
   if (provider === "mysql") {
     if (type === "uuid") return " @db.Char(36)";
-    if (type.startsWith("varchar")) return " @db.VarChar(255)";
+    if (type === "large-string") return " @db.MediumText";
+    if (type.startsWith("varchar")) {
+      return ` @db.VarChar(${varcharLength(type)})`;
+    }
   }
   return "";
 };
@@ -42,6 +50,7 @@ const prismaType = (
 ): string => {
   const base = (() => {
     if (column.type === "bool") return "Boolean";
+    if (column.type === "float") return "Float";
     if (column.type === "integer") return "Int";
     if (column.type === "json") return "Json";
     return "String";
@@ -80,11 +89,14 @@ const prismaField = (
 const relationTargetFields = (
   table: HotUpdaterTableSchema,
   schema: HotUpdaterVersionedSchema,
-): readonly HotUpdaterRelationSchema[] =>
+): readonly {
+  readonly relation: HotUpdaterRelationSchema;
+  readonly sourceTable: HotUpdaterTableSchema;
+}[] =>
   schema.tables.flatMap((sourceTable) =>
-    (sourceTable.relations ?? []).filter(
-      (relation) => relation.referencedTable === table.ormName,
-    ),
+    (sourceTable.relations ?? [])
+      .filter((relation) => relation.referencedTable === table.ormName)
+      .map((relation) => ({ relation, sourceTable })),
   );
 
 const prismaRelationFields = (
@@ -92,14 +104,36 @@ const prismaRelationFields = (
   schema: HotUpdaterVersionedSchema,
 ): string[] => {
   const lines = relationTargetFields(table, schema).map(
-    (relation) =>
-      `${relation.fieldName} ${relation.referencedTable === table.ormName ? "bundle_patches" : relation.referencedTable}[] @relation(${literal(relation.relationName)})`,
+    ({ relation, sourceTable }) =>
+      `${relation.fieldName} ${sourceTable.ormName}[] @relation(${literal(relation.relationName)})`,
   );
 
   for (const relation of table.relations ?? []) {
     const targetType = toPascalCase(relation.referencedTable);
+    const foreignKey = table.foreignKeys?.find(
+      (item) =>
+        item.referencedTable === relation.referencedTable &&
+        item.columns.join("\0") === relation.columns.join("\0") &&
+        item.referencedColumns.join("\0") ===
+          relation.referencedColumns.join("\0"),
+    );
+    if (!foreignKey) {
+      throw new Error(
+        `Missing foreign key metadata for relation ${table.ormName}.${relation.name}`,
+      );
+    }
+    const optional = relation.columns.some(
+      (columnName) =>
+        table.columns.find(({ ormName }) => ormName === columnName)?.nullable,
+    );
+    const onDelete =
+      foreignKey.onDelete === "cascade"
+        ? "Cascade"
+        : foreignKey.onDelete === "set null"
+          ? "SetNull"
+          : "Restrict";
     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)`,
+      `${relation.targetFieldName} ${targetType === "Bundles" ? "bundles" : relation.referencedTable}${optional ? "?" : ""} @relation(${literal(relation.relationName)}, fields: [${relation.columns.join(", ")}], references: [${relation.referencedColumns.join(", ")}], onUpdate: Restrict, onDelete: ${onDelete})`,
     );
   }
 
@@ -114,7 +148,7 @@ const prismaIndexes = (
     .filter((index) => schemaIndexAppliesToProvider(index, provider))
     .map(
       (index) =>
-        `@@index([${index.columns.join(", ")}], map: ${literal(index.name)})`,
+        `@@${index.unique ? "unique" : "index"}([${index.columns.join(", ")}], map: ${literal(index.name)})`,
     );
 
 export const generatePrismaSchema = (
@@ -165,6 +199,12 @@ const drizzleColumnFn = (
         imports: ["integer"],
       };
     }
+    if (column.type === "float") {
+      return {
+        code: `real(${literal(column.ormName)})`,
+        imports: ["real"],
+      };
+    }
     if (column.type === "json") {
       return {
         code: `blob(${literal(column.ormName)}, { mode: "json" })`,
@@ -173,7 +213,7 @@ const drizzleColumnFn = (
     }
     if (column.type.startsWith("varchar")) {
       return {
-        code: `text(${literal(column.ormName)}, { length: 255 })`,
+        code: `text(${literal(column.ormName)}, { length: ${varcharLength(column.type)} })`,
         imports: ["text"],
       };
     }
@@ -196,12 +236,24 @@ const drizzleColumnFn = (
     if (column.type === "integer") {
       return { code: `int(${literal(column.ormName)})`, imports: ["int"] };
     }
+    if (column.type === "float") {
+      return {
+        code: `double(${literal(column.ormName)})`,
+        imports: ["double"],
+      };
+    }
     if (column.type === "json") {
       return { code: `json(${literal(column.ormName)})`, imports: ["json"] };
     }
+    if (column.type === "large-string") {
+      return {
+        code: `mediumtext(${literal(column.ormName)})`,
+        imports: ["mediumtext"],
+      };
+    }
     if (column.type.startsWith("varchar")) {
       return {
-        code: `varchar(${literal(column.ormName)}, { length: 255 })`,
+        code: `varchar(${literal(column.ormName)}, { length: ${varcharLength(column.type)} })`,
         imports: ["varchar"],
       };
     }
@@ -223,12 +275,18 @@ const drizzleColumnFn = (
       imports: ["integer"],
     };
   }
+  if (column.type === "float") {
+    return {
+      code: `doublePrecision(${literal(column.ormName)})`,
+      imports: ["doublePrecision"],
+    };
+  }
   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 })`,
+      code: `varchar(${literal(column.ormName)}, { length: ${varcharLength(column.type)} })`,
       imports: ["varchar"],
     };
   }
@@ -237,7 +295,9 @@ const drizzleColumnFn = (
 
 const drizzleDefault = (value: HotUpdaterDefault | undefined): string => {
   if (!value) return "";
-  if (value.type === "json") return ".default({})";
+  if (value.type === "json") {
+    return `.default(${JSON.stringify(value.value)})`;
+  }
   return `.default(${JSON.stringify(value.value)})`;
 };
 
@@ -276,10 +336,14 @@ const drizzleTable = (
   const callbacks: string[] = [];
   for (const foreignKey of table.foreignKeys ?? []) {
     imports.add("foreignKey");
+    const referencedTable =
+      foreignKey.referencedTable === table.ormName
+        ? "table"
+        : foreignKey.referencedTable;
     callbacks.push(`foreignKey({
     columns: [table.${foreignKey.columns.join(", table.")}],
-    foreignColumns: [${foreignKey.referencedTable}.${foreignKey.referencedColumns.join(
-      `, ${foreignKey.referencedTable}.`,
+    foreignColumns: [${referencedTable}.${foreignKey.referencedColumns.join(
+      `, ${referencedTable}.`,
     )}],
     name: ${literal(foreignKey.name)}
   }).onUpdate(${literal(foreignKey.onUpdate)}).onDelete(${literal(
@@ -289,9 +353,10 @@ const drizzleTable = (
   for (const index of (table.indexes ?? []).filter((item) =>
     schemaIndexAppliesToProvider(item, provider),
   )) {
-    imports.add("index");
+    const indexFunction = index.unique ? "uniqueIndex" : "index";
+    imports.add(indexFunction);
     callbacks.push(
-      `index(${literal(index.name)}).on(${index.columns
+      `${indexFunction}(${literal(index.name)}).on(${index.columns
         .map((column) => `table.${column}`)
         .join(", ")})`,
     );
@@ -310,9 +375,16 @@ const drizzleTable = (
   )})`;
 };
 
-const drizzleRelations = (table: HotUpdaterTableSchema): string | undefined => {
-  if (!table.relations || table.relations.length === 0) return undefined;
-  const lines = table.relations.map(
+const drizzleRelations = (
+  table: HotUpdaterTableSchema,
+  schema: HotUpdaterVersionedSchema,
+): string | undefined => {
+  const sourceRelations = table.relations ?? [];
+  const targetRelations = relationTargetFields(table, schema);
+  if (sourceRelations.length === 0 && targetRelations.length === 0) {
+    return undefined;
+  }
+  const lines = sourceRelations.map(
     (
       relation,
     ) => `  ${relation.targetFieldName}: one(${relation.referencedTable}, {
@@ -323,7 +395,19 @@ const drizzleRelations = (table: HotUpdaterTableSchema): string | undefined => {
       .join(", ")}]
   })`,
   );
-  return `export const ${table.ormName}Relations = relations(${table.ormName}, ({ one }) => ({
+  lines.push(
+    ...targetRelations.map(
+      ({ relation, sourceTable }) =>
+        `  ${relation.fieldName}: many(${sourceTable.ormName}, {
+    relationName: ${literal(relation.relationName)}
+  })`,
+    ),
+  );
+  const callbacks = [
+    ...(sourceRelations.length > 0 ? ["one"] : []),
+    ...(targetRelations.length > 0 ? ["many"] : []),
+  ];
+  return `export const ${table.ormName}Relations = relations(${table.ormName}, ({ ${callbacks.join(", ")} }) => ({
 ${lines.join(",\n")}
 }))`;
 };
@@ -337,7 +421,7 @@ export const generateDrizzleSchema = (
 
   for (const table of schema.tables) {
     body.push(drizzleTable(table, provider, imports));
-    const relations = drizzleRelations(table);
+    const relations = drizzleRelations(table, schema);
     if (relations) body.push(relations);
   }
 

package/src/db/schemaReadiness.ts

@@ -1,4 +1,5 @@
 import { HOT_UPDATER_SCHEMA_VERSION } from "../schema/types";
+import { unsupportedSchemaUpgradeMessage } from "./fixedMigratorShared";
 import type { Migrator } from "./types";
 
 export class HotUpdaterSchemaMigrationRequiredError extends Error {
@@ -9,7 +10,7 @@ export class HotUpdaterSchemaMigrationRequiredError extends Error {
     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}.`,
+        : unsupportedSchemaUpgradeMessage(currentVersion),
     );
     this.name = "HotUpdaterSchemaMigrationRequiredError";
   }

package/src/db/sqlMigrationExecution.spec.ts

@@ -0,0 +1,65 @@
+import { DatabaseSync, type SqliteValue } from "node:sqlite";
+
+import { Kysely, SqliteDialect } from "kysely";
+import { describe, expect, it } from "vitest";
+
+import { executeMigrationStatements } from "./sqlMigrationExecution";
+
+const createSqliteKysely = (database: DatabaseSync): Kysely<object> =>
+  new Kysely<object>({
+    dialect: new SqliteDialect({
+      database: {
+        close: () => database.close(),
+        prepare: (sqlText) => {
+          const statement = database.prepare(sqlText);
+          return {
+            reader: statement.columns().length > 0,
+            all: (parameters) =>
+              statement.all(...(parameters as SqliteValue[])),
+            run: (parameters) => {
+              const result = statement.run(...(parameters as SqliteValue[]));
+              return {
+                changes: result.changes,
+                lastInsertRowid: result.lastInsertRowid,
+              };
+            },
+            iterate: (parameters) =>
+              statement.iterate(...(parameters as SqliteValue[])),
+          };
+        },
+      },
+    }),
+  });
+
+describe("executeMigrationStatements", () => {
+  it("rolls back SQLite statements and restores foreign keys when a statement fails", async () => {
+    const database = new DatabaseSync(":memory:");
+    database.exec("pragma foreign_keys = on");
+    const db = createSqliteKysely(database);
+
+    await expect(
+      executeMigrationStatements({
+        db,
+        provider: "sqlite",
+        statements: [
+          "create table migration_rows (id integer primary key)",
+          "insert into migration_rows (id) values (1)",
+          "insert into missing_rows (id) values (1)",
+        ],
+      }),
+    ).rejects.toThrow("no such table: missing_rows");
+
+    expect(
+      database
+        .prepare(
+          "select name from sqlite_master where type = 'table' and name = 'migration_rows'",
+        )
+        .all(),
+    ).toEqual([]);
+    expect(database.prepare("pragma foreign_keys").get()).toEqual({
+      foreign_keys: 1,
+    });
+
+    await db.destroy();
+  });
+});

package/src/db/sqlMigrationExecution.ts

@@ -0,0 +1,108 @@
+import { sql, type QueryExecutorProvider } from "kysely";
+
+import type { ORMSQLProvider } from "./types";
+
+class SqliteMigrationForeignKeyError extends Error {
+  readonly name = "SqliteMigrationForeignKeyError";
+
+  constructor(readonly violations: number) {
+    super(`SQLite migration produced ${violations} foreign key violation(s).`);
+  }
+}
+
+const executeTransactionalStatements = async (
+  db: QueryExecutorProvider,
+  statements: readonly string[],
+): Promise<void> => {
+  await db.getExecutor().provideConnection(async (connection) => {
+    const execute = (statement: string) =>
+      connection.executeQuery(sql.raw(statement).compile(db));
+    await execute("begin");
+    try {
+      for (const statement of statements) await execute(statement);
+      await execute("commit");
+    } catch (error) {
+      await execute("rollback");
+      throw error;
+    }
+  });
+};
+
+const executeSqliteStatements = async (
+  db: QueryExecutorProvider,
+  statements: readonly string[],
+): Promise<void> => {
+  await db.getExecutor().provideConnection(async (connection) => {
+    const execute = (statement: string) =>
+      connection.executeQuery(sql.raw(statement).compile(db));
+    const foreignKeys = await execute("pragma foreign_keys");
+    const state = foreignKeys.rows[0];
+    const foreignKeysWereEnabled =
+      typeof state === "object" &&
+      state !== null &&
+      "foreign_keys" in state &&
+      state.foreign_keys === 1;
+
+    await execute("pragma foreign_keys = off");
+    try {
+      await execute("begin");
+      try {
+        for (const statement of statements) {
+          if (
+            statement === "pragma foreign_keys = off" ||
+            statement === "pragma foreign_keys = on"
+          ) {
+            continue;
+          }
+          if (statement === "pragma foreign_key_check") {
+            const result = await execute(statement);
+            if (result.rows.length > 0) {
+              throw new SqliteMigrationForeignKeyError(result.rows.length);
+            }
+            continue;
+          }
+          await execute(statement);
+        }
+        await execute("commit");
+      } catch (error) {
+        await execute("rollback");
+        throw error;
+      }
+    } finally {
+      await execute(
+        foreignKeysWereEnabled
+          ? "pragma foreign_keys = on"
+          : "pragma foreign_keys = off",
+      );
+    }
+  });
+};
+
+const executeMysqlStatements = async (
+  db: QueryExecutorProvider,
+  statements: readonly string[],
+): Promise<void> => {
+  for (const statement of statements) {
+    await sql.raw(statement).execute(db);
+  }
+};
+
+export const executeMigrationStatements = async ({
+  db,
+  provider,
+  statements,
+}: {
+  readonly db: QueryExecutorProvider;
+  readonly provider: ORMSQLProvider;
+  readonly statements: readonly string[];
+}): Promise<void> => {
+  if (provider === "mysql") {
+    await executeMysqlStatements(db, statements);
+    return;
+  }
+  if (provider === "sqlite") {
+    await executeSqliteStatements(db, statements);
+    return;
+  }
+  await executeTransactionalStatements(db, statements);
+};

package/src/db/types.spec.ts

@@ -0,0 +1,55 @@
+import { describe, expect, it } from "vitest";
+
+import { createInMemoryDatabasePlugin } from "../../../test-utils/test/inMemoryDatabasePlugin";
+import { isDatabasePlugin } from "./types";
+
+describe("isDatabasePlugin", () => {
+  it("accepts a direct fixed-model plugin object", () => {
+    const plugin = createInMemoryDatabasePlugin();
+
+    const result = isDatabasePlugin(plugin);
+
+    expect(result).toBe(true);
+  });
+
+  it("rejects a v1 factory and malformed required domains", () => {
+    const plugin = createInMemoryDatabasePlugin();
+    const factory = () => plugin;
+    const malformedBundles = {
+      ...plugin,
+      models: {
+        ...plugin.models,
+        bundles: { ...plugin.models.bundles, findMany: null },
+      },
+    };
+    const missingInsights = {
+      ...plugin,
+      models: { ...plugin.models, insights: undefined },
+    };
+    const malformedChannels = {
+      ...plugin,
+      models: {
+        ...plugin.models,
+        channels: { ...plugin.models.channels, delete: null },
+      },
+    };
+    const malformedApiKeys = {
+      ...plugin,
+      models: {
+        ...plugin.models,
+        apiKeys: {
+          ...plugin.models.apiKeys,
+          revoke: null,
+        },
+      },
+    };
+    const malformedDispose = { ...plugin, dispose: null };
+
+    expect(isDatabasePlugin(factory)).toBe(false);
+    expect(isDatabasePlugin(malformedBundles)).toBe(false);
+    expect(isDatabasePlugin(missingInsights)).toBe(false);
+    expect(isDatabasePlugin(malformedChannels)).toBe(false);
+    expect(isDatabasePlugin(malformedApiKeys)).toBe(false);
+    expect(isDatabasePlugin(malformedDispose)).toBe(false);
+  });
+});