@hot-updater/server 0.33.2 → 0.35.0

package/src/db/schemaGenerators.ts

@@ -0,0 +1,382 @@
+import {
+  HOT_UPDATER_SETTINGS_TABLE,
+  type HotUpdaterColumnSchema,
+  type HotUpdaterColumnType,
+  type HotUpdaterDefault,
+  type HotUpdaterRelationSchema,
+  type HotUpdaterTableSchema,
+  type HotUpdaterVersionedSchema,
+} from "../schema/types";
+import {
+  getHotUpdaterSchemaVersion,
+  hotUpdaterSchema,
+  schemaIndexAppliesToProvider,
+} from "./schema/registry";
+import type { ORMProvider, ORMSQLProvider, SchemaGenerator } from "./types";
+import { getSQLProvider } from "./types";
+
+const literal = (value: string): string => JSON.stringify(value);
+
+const toPascalCase = (value: string): string =>
+  value
+    .split("_")
+    .filter(Boolean)
+    .map((part) => `${part.charAt(0).toUpperCase()}${part.slice(1)}`)
+    .join("");
+
+const prismaDb = (type: HotUpdaterColumnType, provider: ORMProvider) => {
+  if (provider === "postgresql") {
+    if (type === "uuid") return " @db.Uuid";
+    if (type.startsWith("varchar")) return " @db.VarChar(255)";
+  }
+  if (provider === "mysql") {
+    if (type === "uuid") return " @db.Char(36)";
+    if (type.startsWith("varchar")) return " @db.VarChar(255)";
+  }
+  return "";
+};
+
+const prismaType = (
+  column: HotUpdaterColumnSchema,
+  provider: ORMProvider,
+): string => {
+  const base = (() => {
+    if (column.type === "bool") return "Boolean";
+    if (column.type === "integer") return "Int";
+    if (column.type === "json") return "Json";
+    return "String";
+  })();
+  return `${base}${column.nullable ? "?" : ""}${prismaDb(
+    column.type,
+    provider,
+  )}`;
+};
+
+const prismaDefault = (
+  column: HotUpdaterColumnSchema,
+  provider: ORMProvider,
+): string => {
+  if (!column.default) return "";
+  if (provider === "sqlite" && column.type === "json") return "";
+  if (column.default.type === "json") {
+    return ` @default(${literal(JSON.stringify(column.default.value))})`;
+  }
+  return ` @default(${JSON.stringify(column.default.value)})`;
+};
+
+const prismaField = (
+  column: HotUpdaterColumnSchema,
+  provider: ORMProvider,
+): string =>
+  [
+    column.ormName,
+    prismaType(column, provider),
+    column.primaryKey ? "@id" : undefined,
+    prismaDefault(column, provider).trim() || undefined,
+  ]
+    .filter(Boolean)
+    .join(" ");
+
+const relationTargetFields = (
+  table: HotUpdaterTableSchema,
+  schema: HotUpdaterVersionedSchema,
+): readonly HotUpdaterRelationSchema[] =>
+  schema.tables.flatMap((sourceTable) =>
+    (sourceTable.relations ?? []).filter(
+      (relation) => relation.referencedTable === table.ormName,
+    ),
+  );
+
+const prismaRelationFields = (
+  table: HotUpdaterTableSchema,
+  schema: HotUpdaterVersionedSchema,
+): string[] => {
+  const lines = relationTargetFields(table, schema).map(
+    (relation) =>
+      `${relation.fieldName} ${relation.referencedTable === table.ormName ? "bundle_patches" : relation.referencedTable}[] @relation(${literal(relation.relationName)})`,
+  );
+
+  for (const relation of table.relations ?? []) {
+    const targetType = toPascalCase(relation.referencedTable);
+    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)`,
+    );
+  }
+
+  return lines;
+};
+
+const prismaIndexes = (
+  table: HotUpdaterTableSchema,
+  provider: ORMProvider,
+): string[] =>
+  (table.indexes ?? [])
+    .filter((index) => schemaIndexAppliesToProvider(index, provider))
+    .map(
+      (index) =>
+        `@@index([${index.columns.join(", ")}], map: ${literal(index.name)})`,
+    );
+
+export const generatePrismaSchema = (
+  provider: ORMProvider,
+  schema: HotUpdaterVersionedSchema = hotUpdaterSchema,
+) =>
+  schema.tables
+    .map((table) => {
+      const lines = [
+        ...table.columns.map((column) => prismaField(column, provider)),
+        ...prismaRelationFields(table, schema),
+        ...prismaIndexes(table, provider),
+      ];
+      return `model ${table.ormName} {\n${lines
+        .map((line) => `  ${line}`)
+        .join("\n")}\n}`;
+    })
+    .join("\n\n");
+
+const drizzleImportSource = (provider: ORMSQLProvider) =>
+  provider === "sqlite"
+    ? "drizzle-orm/sqlite-core"
+    : provider === "mysql"
+      ? "drizzle-orm/mysql-core"
+      : "drizzle-orm/pg-core";
+
+const drizzleTableFn = (provider: ORMSQLProvider) =>
+  provider === "sqlite"
+    ? "sqliteTable"
+    : provider === "mysql"
+      ? "mysqlTable"
+      : "pgTable";
+
+const drizzleColumnFn = (
+  column: HotUpdaterColumnSchema,
+  provider: ORMSQLProvider,
+): { code: string; imports: readonly string[] } => {
+  if (provider === "sqlite") {
+    if (column.type === "bool") {
+      return {
+        code: `integer(${literal(column.ormName)}, { mode: "boolean" })`,
+        imports: ["integer"],
+      };
+    }
+    if (column.type === "integer") {
+      return {
+        code: `integer(${literal(column.ormName)})`,
+        imports: ["integer"],
+      };
+    }
+    if (column.type === "json") {
+      return {
+        code: `blob(${literal(column.ormName)}, { mode: "json" })`,
+        imports: ["blob"],
+      };
+    }
+    if (column.type.startsWith("varchar")) {
+      return {
+        code: `text(${literal(column.ormName)}, { length: 255 })`,
+        imports: ["text"],
+      };
+    }
+    return { code: `text(${literal(column.ormName)})`, imports: ["text"] };
+  }
+
+  if (provider === "mysql") {
+    if (column.type === "uuid") {
+      return {
+        code: `char(${literal(column.ormName)}, { length: 36 })`,
+        imports: ["char"],
+      };
+    }
+    if (column.type === "bool") {
+      return {
+        code: `boolean(${literal(column.ormName)})`,
+        imports: ["boolean"],
+      };
+    }
+    if (column.type === "integer") {
+      return { code: `int(${literal(column.ormName)})`, imports: ["int"] };
+    }
+    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 })`,
+        imports: ["varchar"],
+      };
+    }
+    return { code: `text(${literal(column.ormName)})`, imports: ["text"] };
+  }
+
+  if (column.type === "uuid") {
+    return { code: `uuid(${literal(column.ormName)})`, imports: ["uuid"] };
+  }
+  if (column.type === "bool") {
+    return {
+      code: `boolean(${literal(column.ormName)})`,
+      imports: ["boolean"],
+    };
+  }
+  if (column.type === "integer") {
+    return {
+      code: `integer(${literal(column.ormName)})`,
+      imports: ["integer"],
+    };
+  }
+  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 })`,
+      imports: ["varchar"],
+    };
+  }
+  return { code: `text(${literal(column.ormName)})`, imports: ["text"] };
+};
+
+const drizzleDefault = (value: HotUpdaterDefault | undefined): string => {
+  if (!value) return "";
+  if (value.type === "json") return ".default({})";
+  return `.default(${JSON.stringify(value.value)})`;
+};
+
+const drizzleColumn = (
+  table: HotUpdaterTableSchema,
+  column: HotUpdaterColumnSchema,
+): HotUpdaterColumnSchema => {
+  if (table.ormName !== HOT_UPDATER_SETTINGS_TABLE) return column;
+  if (column.ormName === "key") {
+    return { ...column, ormName: "id", type: "varchar(255)" };
+  }
+  if (column.ormName === "value") {
+    return { ...column, ormName: "version", type: "varchar(255)" };
+  }
+  return column;
+};
+
+const drizzleTable = (
+  table: HotUpdaterTableSchema,
+  provider: ORMSQLProvider,
+  imports: Set<string>,
+): string => {
+  const columns = table.columns.map((sourceColumn) => {
+    const column = drizzleColumn(table, sourceColumn);
+    const type = drizzleColumnFn(column, provider);
+    for (const item of type.imports) imports.add(item);
+    const chain = [
+      type.code,
+      column.primaryKey ? "primaryKey()" : undefined,
+      column.nullable ? undefined : "notNull()",
+      drizzleDefault(column.default).slice(1) || undefined,
+    ].filter(Boolean);
+    return `  ${column.ormName}: ${chain.join(".")}`;
+  });
+
+  const callbacks: string[] = [];
+  for (const foreignKey of table.foreignKeys ?? []) {
+    imports.add("foreignKey");
+    callbacks.push(`foreignKey({
+    columns: [table.${foreignKey.columns.join(", table.")}],
+    foreignColumns: [${foreignKey.referencedTable}.${foreignKey.referencedColumns.join(
+      `, ${foreignKey.referencedTable}.`,
+    )}],
+    name: ${literal(foreignKey.name)}
+  }).onUpdate(${literal(foreignKey.onUpdate)}).onDelete(${literal(
+    foreignKey.onDelete,
+  )})`);
+  }
+  for (const index of (table.indexes ?? []).filter((item) =>
+    schemaIndexAppliesToProvider(item, provider),
+  )) {
+    imports.add("index");
+    callbacks.push(
+      `index(${literal(index.name)}).on(${index.columns
+        .map((column) => `table.${column}`)
+        .join(", ")})`,
+    );
+  }
+
+  const args = [
+    literal(table.ormName),
+    `{\n${columns.join(",\n")}\n}`,
+    callbacks.length > 0
+      ? `(table) => [\n${callbacks.map((line) => `  ${line}`).join(",\n")}\n]`
+      : undefined,
+  ].filter(Boolean);
+
+  return `export const ${table.ormName} = ${drizzleTableFn(provider)}(${args.join(
+    ", ",
+  )})`;
+};
+
+const drizzleRelations = (table: HotUpdaterTableSchema): string | undefined => {
+  if (!table.relations || table.relations.length === 0) return undefined;
+  const lines = table.relations.map(
+    (
+      relation,
+    ) => `  ${relation.targetFieldName}: one(${relation.referencedTable}, {
+    relationName: ${literal(relation.relationName)},
+    fields: [${relation.columns.map((column) => `${table.ormName}.${column}`).join(", ")}],
+    references: [${relation.referencedColumns
+      .map((column) => `${relation.referencedTable}.${column}`)
+      .join(", ")}]
+  })`,
+  );
+  return `export const ${table.ormName}Relations = relations(${table.ormName}, ({ one }) => ({
+${lines.join(",\n")}
+}))`;
+};
+
+export const generateDrizzleSchema = (
+  provider: ORMSQLProvider,
+  schema: HotUpdaterVersionedSchema = hotUpdaterSchema,
+) => {
+  const imports = new Set<string>([drizzleTableFn(provider)]);
+  const body: string[] = [];
+
+  for (const table of schema.tables) {
+    body.push(drizzleTable(table, provider, imports));
+    const relations = drizzleRelations(table);
+    if (relations) body.push(relations);
+  }
+
+  if (body.some((block) => block.includes("relations("))) {
+    body.unshift('import { relations } from "drizzle-orm"');
+  }
+
+  const importLine = `import { ${Array.from(imports)
+    .sort()
+    .join(", ")} } from "${drizzleImportSource(provider)}"`;
+
+  return [importLine, ...body].join("\n\n");
+};
+
+export const generateSchemaFromHotUpdaterSchema = (
+  adapterName: string,
+  provider: ORMProvider | undefined,
+  version: string | "latest",
+  fallback: ReturnType<SchemaGenerator>,
+): ReturnType<SchemaGenerator> => {
+  const schema =
+    version === "latest"
+      ? hotUpdaterSchema
+      : getHotUpdaterSchemaVersion(version);
+
+  if (adapterName === "prisma" && provider) {
+    return {
+      ...fallback,
+      code: generatePrismaSchema(provider, schema),
+    };
+  }
+
+  const sqlProvider = getSQLProvider(provider);
+  if (adapterName === "drizzle" && sqlProvider) {
+    return {
+      ...fallback,
+      code: generateDrizzleSchema(sqlProvider, schema),
+    };
+  }
+
+  return fallback;
+};

package/src/db/schemaReadiness.ts

@@ -0,0 +1,33 @@
+import { HOT_UPDATER_SCHEMA_VERSION } from "../schema/types";
+import type { Migrator } from "./types";
+
+export class HotUpdaterSchemaMigrationRequiredError extends Error {
+  constructor(
+    readonly adapterName: string,
+    readonly currentVersion: string | undefined,
+  ) {
+    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}.`,
+    );
+    this.name = "HotUpdaterSchemaMigrationRequiredError";
+  }
+}
+
+export const createSchemaReadinessChecker = (
+  adapterName: string,
+  createMigrator: (() => Migrator) | undefined,
+): (() => Promise<void>) => {
+  if (!createMigrator) return async () => {};
+
+  let ready = false;
+  return async () => {
+    if (ready) return;
+    const version = await createMigrator().getVersion();
+    if (version !== HOT_UPDATER_SCHEMA_VERSION) {
+      throw new HotUpdaterSchemaMigrationRequiredError(adapterName, version);
+    }
+    ready = true;
+  };
+};

package/src/db/types.ts

@@ -10,34 +10,84 @@ import type {
   HotUpdaterContext,
   RuntimeStoragePlugin,
 } from "@hot-updater/plugin-core";
-import { sqlProviders, type Provider, type SQLProvider } from "fumadb";
 
 import type { PaginatedResult } from "../types";
 
 export type DatabasePluginFactory<TContext = unknown> =
-  () => DatabasePlugin<TContext>;
+  (() => DatabasePlugin<TContext>) & Partial<DatabaseAdapterCapabilities>;
 
-export type ORMProvider = Provider;
-export type ORMSQLProvider = SQLProvider;
+export const sqlProviders = [
+  "sqlite",
+  "cockroachdb",
+  "mysql",
+  "postgresql",
+  "mssql",
+] as const;
 
-export interface ORMDatabaseAdapter {
-  name: string;
+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";
+  updateSettings?: boolean;
+  unsafe?: boolean;
+}
+
+export type MigrationOperation =
+  | {
+      type: "create-table";
+      value: {
+        ormName: string;
+        columns: Record<string, { ormName: string; type: string }>;
+      };
+    }
+  | { type: "custom"; sql: string }
+  | { type: "custom"; key: string; value: unknown };
+
+export interface MigrationResult {
+  operations: MigrationOperation[];
+  execute: () => Promise<void>;
+  getSQL?: () => string;
+}
+
+export interface Migrator {
+  getVersion: () => Promise<string | undefined>;
+  getNameVariants: () => Promise<unknown>;
+  next: () => Promise<{ version: string } | undefined>;
+  previous: () => Promise<{ version: string } | undefined>;
+  up: (options?: MigrateOptions) => Promise<MigrationResult>;
+  down: (options?: MigrateOptions) => Promise<MigrationResult>;
+  migrateTo: (
+    version: string,
+    options?: MigrateOptions,
+  ) => Promise<MigrationResult>;
+  migrateToLatest: (options?: MigrateOptions) => Promise<MigrationResult>;
+}
+
+export type SchemaGenerator = (
+  version: string | "latest",
+  name?: string,
+) => {
+  code: string;
+  path: string;
+};
+
+export interface DatabaseAdapterCapabilities {
+  adapterName?: string;
   provider?: ORMProvider;
-  createORM(this: any, schema: any): unknown;
-  getSchemaVersion(this: any): Promise<string | undefined>;
-  generateSchema?: (
-    this: any,
-    schema: any,
-    schemaName: string,
-  ) => {
-    code: string;
-    path: string;
-  };
-  createMigrationEngine?: (this: any) => unknown;
+  createMigrator?: () => Migrator;
+  generateSchema?: SchemaGenerator;
 }
 
+export type DatabaseAdapterWithCapabilities<TContext = unknown> =
+  DatabasePlugin<TContext> & DatabaseAdapterCapabilities;
+
 export type DatabaseAdapter<TContext = unknown> =
-  | ORMDatabaseAdapter
+  | DatabaseAdapterWithCapabilities<TContext>
   | DatabasePlugin<TContext>
   | DatabasePluginFactory<TContext>;
 
@@ -59,12 +109,6 @@ export function isDatabasePlugin<TContext = unknown>(
   );
 }
 
-export function isFumaAdapter<TContext = unknown>(
-  adapter: DatabaseAdapter<TContext>,
-): adapter is ORMDatabaseAdapter {
-  return !isDatabasePluginFactory(adapter) && !isDatabasePlugin(adapter);
-}
-
 export function getSQLProvider(
   provider: ORMProvider | undefined,
 ): ORMSQLProvider | undefined {
@@ -72,7 +116,7 @@ export function getSQLProvider(
     return undefined;
   }
 
-  return sqlProviders.includes(provider as ORMSQLProvider)
+  return (sqlProviders as readonly string[]).includes(provider)
     ? (provider as ORMSQLProvider)
     : undefined;
 }

package/src/handler-standalone.integration.spec.ts

@@ -11,7 +11,8 @@ import { afterAll, afterEach, beforeAll, describe, expect, it } from "vitest";
 
 import { standaloneRepository } from "../../../plugins/standalone/src";
 import { kyselyAdapter } from "./adapters/kysely";
-import { createHotUpdater } from "./db";
+import { createMigrator } from "./db";
+import { createHotUpdater } from "./index";
 
 /**
  * Integration tests between @hot-updater/server handler and @hot-updater/standalone repository
@@ -46,7 +47,7 @@ const server = setupServer();
 
 beforeAll(async () => {
   // Initialize database
-  const migrator = api.createMigrator();
+  const migrator = createMigrator(api);
   const result = await migrator.migrateToLatest({
     mode: "from-schema",
     updateSettings: true,

package/src/index.ts

@@ -1,4 +1,10 @@
-export * from "./db";
-export * from "./handler";
+export { createHandler } from "./handler";
+export type { HandlerAPI, HandlerOptions, HandlerRoutes } from "./handler";
+export { createHotUpdater } from "./createHotUpdaterCore";
+export type {
+  CreateHotUpdaterOptions,
+  HotUpdaterAPI,
+  RuntimeHotUpdaterAPI,
+} from "./createHotUpdaterCore";
 export * from "./types";
-export * from "./version";
+export { HOT_UPDATER_SERVER_VERSION } from "./version";

package/src/node.spec.ts

@@ -0,0 +1,50 @@
+import { describe, expect, it } from "vitest";
+
+import { toNodeHandler } from "./node";
+
+describe("server node entry", () => {
+  it("converts a Web Request handler to Node middleware", async () => {
+    const hotUpdater = {
+      handler: async (request: Request) =>
+        Response.json({
+          method: request.method,
+          pathname: new URL(request.url).pathname,
+        }),
+    };
+    const middleware = toNodeHandler(hotUpdater);
+    const headers = new Map<string, string | string[]>();
+    const response = {
+      body: "",
+      statusCode: 0,
+      status(code: number) {
+        this.statusCode = code;
+        return this;
+      },
+      setHeader(name: string, value: string | string[]) {
+        headers.set(name, value);
+      },
+      send(body: string) {
+        this.body = body;
+      },
+      end() {},
+    };
+
+    await middleware(
+      {
+        method: "GET",
+        url: "/api/check",
+        headers: { host: "example.com" },
+        protocol: "https",
+        get: (name: string) => (name === "host" ? "example.com" : undefined),
+      },
+      response,
+    );
+
+    expect(response.statusCode).toBe(200);
+    expect(headers.get("content-type")).toContain("application/json");
+    expect(JSON.parse(response.body)).toEqual({
+      method: "GET",
+      pathname: "/api/check",
+    });
+  });
+});

package/src/node.ts

@@ -1,5 +1,3 @@
-import type { HotUpdaterAPI } from "./types";
-
 /**
  * Node.js request/response types (compatible with Express, Connect, etc.)
  */
@@ -21,6 +19,12 @@ interface NodeResponse {
   [key: string]: unknown;
 }
 
+type HandlerHotUpdaterAPI = {
+  readonly handler: (request: Request) => Promise<Response>;
+};
+
+export { HOT_UPDATER_SERVER_VERSION } from "./version";
+
 /**
  * Converts a Hot Updater handler to a Node.js-compatible middleware
  * Works with Express, Connect, and other frameworks using Node.js req/res
@@ -40,7 +44,7 @@ interface NodeResponse {
  * ```
  */
 export function toNodeHandler(
-  hotUpdater: HotUpdaterAPI,
+  hotUpdater: HandlerHotUpdaterAPI,
 ): (req: any, res: any, next?: any) => Promise<void> {
   return async (req: NodeRequest, res: NodeResponse) => {
     try {