@hot-updater/server 0.27.1 → 0.29.0

package/src/runtime.spec.ts

@@ -0,0 +1,277 @@
+import type { Bundle } from "@hot-updater/core";
+import { NIL_UUID } from "@hot-updater/core";
+import type {
+  DatabasePlugin,
+  RequestEnvContext,
+  StoragePlugin,
+} from "@hot-updater/plugin-core";
+import { describe, expect, expectTypeOf, it, vi } from "vitest";
+import { createHotUpdater } from "./runtime";
+
+const bundle: Bundle = {
+  id: "00000000-0000-0000-0000-000000000001",
+  platform: "ios",
+  shouldForceUpdate: false,
+  enabled: true,
+  fileHash: "hash123",
+  gitCommitHash: null,
+  message: "Test bundle",
+  channel: "production",
+  storageUri: "s3://test-bucket/bundles/bundle.zip",
+  targetAppVersion: "1.0.0",
+  fingerprintHash: null,
+};
+
+type TestEnv = {
+  assetHost: string;
+};
+
+type TestContext = RequestEnvContext<TestEnv>;
+
+describe("runtime createHotUpdater", () => {
+  it("passes the handler context to database and storage resolution", async () => {
+    const request = new Request(
+      "https://updates.example.com/api/check-update/app-version/ios/1.0.0/production/" +
+        `${NIL_UUID}/${NIL_UUID}`,
+    );
+    const getBundles = vi.fn<DatabasePlugin<TestContext>["getBundles"]>(
+      async () => {
+        return {
+          data: [bundle],
+          pagination: {
+            hasNextPage: false,
+            hasPreviousPage: false,
+            currentPage: 1,
+            totalPages: 1,
+            total: 1,
+          },
+        };
+      },
+    );
+    const getDownloadUrl = vi.fn<StoragePlugin<TestContext>["getDownloadUrl"]>(
+      async (_storageUri, context) => {
+        return {
+          fileUrl: new URL("/bundle.zip", context?.env?.assetHost).toString(),
+        };
+      },
+    );
+
+    const database: DatabasePlugin<TestContext> = {
+      name: "testDatabase",
+      async appendBundle() {},
+      async commitBundle() {},
+      async deleteBundle() {},
+      async getBundleById(id) {
+        return id === bundle.id ? bundle : null;
+      },
+      getBundles,
+      async getChannels() {
+        return ["production"];
+      },
+      async onUnmount() {},
+      async updateBundle() {},
+    };
+    const storage: StoragePlugin<TestContext> = {
+      name: "testStorage",
+      supportedProtocol: "s3",
+      async upload(key) {
+        return { storageUri: `s3://test-bucket/${key}` };
+      },
+      async delete() {},
+      getDownloadUrl,
+    };
+
+    const hotUpdater = createHotUpdater({
+      database,
+      storages: [storage],
+      basePath: "/api/check-update",
+      routes: {
+        updateCheck: true,
+        bundles: false,
+      },
+    });
+
+    expectTypeOf(hotUpdater.handler)
+      .parameter(1)
+      .toEqualTypeOf<TestContext | undefined>();
+
+    const response = await hotUpdater.handler(request, {
+      env: {
+        assetHost: "https://assets.example.com",
+      },
+      request,
+    });
+
+    expect(response.status).toBe(200);
+    await expect(response.json()).resolves.toEqual({
+      fileHash: "hash123",
+      fileUrl: "https://assets.example.com/bundle.zip",
+      id: "00000000-0000-0000-0000-000000000001",
+      message: "Test bundle",
+      shouldForceUpdate: false,
+      status: "UPDATE",
+    });
+    expect(getBundles).toHaveBeenCalledWith(
+      expect.any(Object),
+      expect.objectContaining({
+        env: {
+          assetHost: "https://assets.example.com",
+        },
+        request: expect.any(Request),
+      }),
+    );
+    expect(getDownloadUrl).toHaveBeenCalledWith(
+      "s3://test-bucket/bundles/bundle.zip",
+      expect.objectContaining({
+        env: {
+          assetHost: "https://assets.example.com",
+        },
+        request: expect.any(Request),
+      }),
+    );
+  });
+
+  it("does not inject the request into context unless explicitly provided", async () => {
+    const getBundles = vi.fn<DatabasePlugin<TestContext>["getBundles"]>(
+      async () => {
+        return {
+          data: [bundle],
+          pagination: {
+            hasNextPage: false,
+            hasPreviousPage: false,
+            currentPage: 1,
+            totalPages: 1,
+            total: 1,
+          },
+        };
+      },
+    );
+
+    const database: DatabasePlugin<TestContext> = {
+      name: "testDatabase",
+      async appendBundle() {},
+      async commitBundle() {},
+      async deleteBundle() {},
+      async getBundleById(id) {
+        return id === bundle.id ? bundle : null;
+      },
+      getBundles,
+      async getChannels() {
+        return ["production"];
+      },
+      async onUnmount() {},
+      async updateBundle() {},
+    };
+    const storage: StoragePlugin<TestContext> = {
+      name: "testStorage",
+      supportedProtocol: "s3",
+      async upload(key) {
+        return { storageUri: `s3://test-bucket/${key}` };
+      },
+      async delete() {},
+      async getDownloadUrl() {
+        return { fileUrl: "https://assets.example.com/bundle.zip" };
+      },
+    };
+
+    const hotUpdater = createHotUpdater({
+      database,
+      storages: [storage],
+      basePath: "/api/check-update",
+      routes: {
+        updateCheck: true,
+        bundles: false,
+      },
+    });
+
+    const response = await hotUpdater.handler(
+      new Request(
+        "https://updates.example.com/api/check-update/app-version/ios/1.0.0/production/" +
+          `${NIL_UUID}/${NIL_UUID}`,
+      ),
+      {
+        env: {
+          assetHost: "https://assets.example.com",
+        },
+      },
+    );
+
+    expect(response.status).toBe(200);
+    expect(getBundles).toHaveBeenCalledWith(expect.any(Object), {
+      env: {
+        assetHost: "https://assets.example.com",
+      },
+    });
+  });
+
+  it("supports stripped base-path requests and ignores extra framework args", async () => {
+    const getBundles = vi.fn<DatabasePlugin<TestContext>["getBundles"]>(
+      async () => {
+        return {
+          data: [bundle],
+          pagination: {
+            hasNextPage: false,
+            hasPreviousPage: false,
+            currentPage: 1,
+            totalPages: 1,
+            total: 1,
+          },
+        };
+      },
+    );
+
+    const database: DatabasePlugin<TestContext> = {
+      name: "testDatabase",
+      async appendBundle() {},
+      async commitBundle() {},
+      async deleteBundle() {},
+      async getBundleById(id) {
+        return id === bundle.id ? bundle : null;
+      },
+      getBundles,
+      async getChannels() {
+        return ["production"];
+      },
+      async onUnmount() {},
+      async updateBundle() {},
+    };
+    const storage: StoragePlugin<TestContext> = {
+      name: "testStorage",
+      supportedProtocol: "s3",
+      async upload(key) {
+        return { storageUri: `s3://test-bucket/${key}` };
+      },
+      async delete() {},
+      async getDownloadUrl() {
+        return { fileUrl: "https://assets.example.com/bundle.zip" };
+      },
+    };
+
+    const hotUpdater = createHotUpdater({
+      database,
+      storages: [storage],
+      basePath: "/api/check-update",
+      routes: {
+        updateCheck: true,
+        bundles: false,
+      },
+    });
+
+    const mountStyleHandler = hotUpdater.handler as (
+      request: Request,
+      context?: unknown,
+      executionCtx?: unknown,
+    ) => Promise<Response>;
+    const response = await mountStyleHandler(
+      new Request(
+        "https://updates.example.com/app-version/ios/1.0.0/production/" +
+          `${NIL_UUID}/${NIL_UUID}`,
+      ),
+      { someBinding: "ignored" },
+      { waitUntil: () => undefined },
+    );
+
+    expect(response.status).toBe(200);
+    expect(getBundles).toHaveBeenCalledWith(expect.any(Object), undefined);
+  });
+});

package/src/runtime.ts

@@ -0,0 +1,121 @@
+import type {
+  HotUpdaterContext,
+  StoragePlugin,
+} from "@hot-updater/plugin-core";
+import { createPluginDatabaseCore } from "./db/pluginCore";
+import {
+  type DatabaseAdapter,
+  type DatabaseAPI,
+  isDatabasePlugin,
+  isDatabasePluginFactory,
+  type StoragePluginFactory,
+} from "./db/types";
+import { createHandler, type HandlerRoutes } from "./handler";
+import { normalizeBasePath } from "./route";
+
+export type HotUpdaterAPI<TContext = unknown> = DatabaseAPI<TContext> & {
+  basePath: string;
+  handler: (
+    request: Request,
+    context?: HotUpdaterContext<TContext>,
+  ) => Promise<Response>;
+  adapterName: string;
+};
+
+export interface CreateHotUpdaterOptions<TContext = unknown> {
+  database: DatabaseAdapter<TContext>;
+  storages?: (StoragePlugin<TContext> | StoragePluginFactory<TContext>)[];
+  storagePlugins?: (StoragePlugin<TContext> | StoragePluginFactory<TContext>)[];
+  basePath?: string;
+  cwd?: string;
+  routes?: HandlerRoutes;
+}
+
+export function createHotUpdater<TContext = unknown>(
+  options: CreateHotUpdaterOptions<TContext>,
+): HotUpdaterAPI<TContext> {
+  const basePath = normalizeBasePath(options.basePath ?? "/api");
+  const storagePlugins = (options.storages ?? options.storagePlugins ?? []).map(
+    (plugin) => (typeof plugin === "function" ? plugin() : plugin),
+  );
+
+  const resolveStoragePluginUrl = async (
+    storageUri: string | null,
+    context?: HotUpdaterContext<TContext>,
+  ): Promise<string | null> => {
+    if (!storageUri) {
+      return null;
+    }
+
+    const url = new URL(storageUri);
+    const protocol = url.protocol.replace(":", "");
+
+    if (protocol === "http" || protocol === "https") {
+      return storageUri;
+    }
+
+    const plugin = storagePlugins.find(
+      (item) => item.supportedProtocol === protocol,
+    );
+
+    if (!plugin) {
+      throw new Error(`No storage plugin for protocol: ${protocol}`);
+    }
+
+    const { fileUrl } = await plugin.getDownloadUrl(storageUri, context);
+    if (!fileUrl) {
+      throw new Error("Storage plugin returned empty fileUrl");
+    }
+
+    return fileUrl;
+  };
+
+  if (
+    !isDatabasePluginFactory(options.database) &&
+    !isDatabasePlugin(options.database)
+  ) {
+    throw new Error(
+      "@hot-updater/server/runtime only supports database plugins.",
+    );
+  }
+
+  const plugin = isDatabasePluginFactory(options.database)
+    ? options.database()
+    : options.database;
+  const core = createPluginDatabaseCore<TContext>(
+    plugin,
+    resolveStoragePluginUrl,
+  );
+
+  const api = {
+    ...core.api,
+    handler: createHandler(core.api, {
+      basePath,
+      routes: options.routes,
+    }),
+    adapterName: core.adapterName,
+  };
+
+  // Some framework adapters strip the mounted base path or pass extra
+  // bindings/execution context arguments. Ignore those extras here so the
+  // handler can still be mounted directly as a plain Request handler.
+  const handler: HotUpdaterAPI<TContext>["handler"] = (
+    request,
+    context,
+    ...extraArgs: unknown[]
+  ) => {
+    if (extraArgs.length > 0) {
+      return api.handler(request);
+    }
+
+    return api.handler(request, context);
+  };
+
+  return {
+    ...api,
+    basePath,
+    handler,
+  };
+}
+
+export { createHandler };

package/src/schema/v0_29_0.ts

@@ -0,0 +1,26 @@
+import { column, idColumn, schema, table } from "fumadb/schema";
+
+export const v0_29_0 = schema({
+  version: "0.29.0",
+  tables: {
+    bundles: table("bundles", {
+      id: idColumn("id", "uuid"),
+      platform: column("platform", "string"),
+      should_force_update: column("should_force_update", "bool"),
+      enabled: column("enabled", "bool"),
+      file_hash: column("file_hash", "string"),
+      git_commit_hash: column("git_commit_hash", "string").nullable(),
+      message: column("message", "string").nullable(),
+      channel: column("channel", "string"),
+      storage_uri: column("storage_uri", "string"),
+      target_app_version: column("target_app_version", "string").nullable(),
+      fingerprint_hash: column("fingerprint_hash", "string").nullable(),
+      metadata: column("metadata", "json"),
+      rollout_cohort_count: column("rollout_cohort_count", "integer").defaultTo(
+        1000,
+      ),
+      target_cohorts: column("target_cohorts", "json").nullable(),
+    }),
+  },
+  relations: {},
+});

package/dist/_virtual/rolldown_runtime.cjs

@@ -1,25 +0,0 @@
-//#region rolldown:runtime
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-		key = keys[i];
-		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-			get: ((k) => from[k]).bind(null, key),
-			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-		});
-	}
-	return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-	value: mod,
-	enumerable: true
-}) : target, mod));
-
-//#endregion
-
-exports.__toESM = __toESM;

package/dist/adapters/drizzle.js

@@ -1,3 +0,0 @@
-export * from "fumadb/adapters/drizzle"
-
-export {  };

package/dist/adapters/kysely.js

@@ -1,3 +0,0 @@
-export * from "fumadb/adapters/kysely"
-
-export {  };

package/dist/adapters/mongodb.js

@@ -1,3 +0,0 @@
-export * from "fumadb/adapters/mongodb"
-
-export {  };

package/dist/adapters/prisma.js

@@ -1,3 +0,0 @@
-export * from "fumadb/adapters/prisma"
-
-export {  };

package/dist/db/index.d.ts

@@ -1,27 +0,0 @@
-import { DatabaseAPI, DatabaseAdapter, StoragePluginFactory } from "./types.js";
-import { HotUpdaterClient, HotUpdaterDB, Migrator } from "./ormCore.js";
-import { StoragePlugin } from "@hot-updater/plugin-core";
-
-//#region src/db/index.d.ts
-type HotUpdaterAPI = DatabaseAPI & {
-  handler: (request: Request) => Promise<Response>;
-  adapterName: string;
-  createMigrator: () => Migrator;
-  generateSchema: HotUpdaterClient["generateSchema"];
-};
-interface HotUpdaterOptions {
-  database: DatabaseAdapter;
-  /**
-   * Storage plugins for handling file uploads and downloads.
-   */
-  storages?: (StoragePlugin | StoragePluginFactory)[];
-  /**
-   * @deprecated Use `storages` instead. This field will be removed in a future version.
-   */
-  storagePlugins?: (StoragePlugin | StoragePluginFactory)[];
-  basePath?: string;
-  cwd?: string;
-}
-declare function createHotUpdater(options: HotUpdaterOptions): HotUpdaterAPI;
-//#endregion
-export { HotUpdaterAPI, createHotUpdater };

package/dist/db/index.js

@@ -1,36 +0,0 @@
-import { createHandler } from "../handler.js";
-import { HotUpdaterDB, createOrmDatabaseCore } from "./ormCore.js";
-import { createPluginDatabaseCore } from "./pluginCore.js";
-import { isDatabasePlugin, isDatabasePluginFactory } from "./types.js";
-
-//#region src/db/index.ts
-function createHotUpdater(options) {
-	const storagePlugins = (options?.storages ?? options?.storagePlugins ?? []).map((plugin) => typeof plugin === "function" ? plugin() : plugin);
-	const resolveFileUrl = async (storageUri) => {
-		if (!storageUri) return null;
-		const protocol = new URL(storageUri).protocol.replace(":", "");
-		if (protocol === "http" || protocol === "https") return storageUri;
-		const plugin = storagePlugins.find((p) => p.supportedProtocol === protocol);
-		if (!plugin) throw new Error(`No storage plugin for protocol: ${protocol}`);
-		const { fileUrl } = await plugin.getDownloadUrl(storageUri);
-		if (!fileUrl) throw new Error("Storage plugin returned empty fileUrl");
-		return fileUrl;
-	};
-	let core;
-	const database = options.database;
-	if (isDatabasePluginFactory(database) || isDatabasePlugin(database)) core = createPluginDatabaseCore(isDatabasePluginFactory(database) ? database() : database, resolveFileUrl);
-	else core = createOrmDatabaseCore({
-		database,
-		resolveFileUrl
-	});
-	return {
-		...core.api,
-		handler: createHandler(core.api, options?.basePath ? { basePath: options.basePath } : {}),
-		adapterName: core.adapterName,
-		createMigrator: core.createMigrator,
-		generateSchema: core.generateSchema
-	};
-}
-
-//#endregion
-export { createHotUpdater };

package/dist/db/ormCore.d.ts

@@ -1,26 +0,0 @@
-import * as fumadb0 from "fumadb";
-import { InferFumaDB } from "fumadb";
-import * as fumadb_schema0 from "fumadb/schema";
-import { FumaDBAdapter } from "fumadb/adapters";
-
-//#region src/db/ormCore.d.ts
-declare const HotUpdaterDB: fumadb0.FumaDBFactory<fumadb_schema0.Schema<"0.21.0", {
-  bundles: fumadb_schema0.Table<{
-    id: fumadb_schema0.IdColumn<"uuid", string, string>;
-    platform: fumadb_schema0.Column<"string", string, string>;
-    should_force_update: fumadb_schema0.Column<"bool", boolean, boolean>;
-    enabled: fumadb_schema0.Column<"bool", boolean, boolean>;
-    file_hash: fumadb_schema0.Column<"string", string, string>;
-    git_commit_hash: fumadb_schema0.Column<"string", string | null, string | null>;
-    message: fumadb_schema0.Column<"string", string | null, string | null>;
-    channel: fumadb_schema0.Column<"string", string, string>;
-    storage_uri: fumadb_schema0.Column<"string", string, string>;
-    target_app_version: fumadb_schema0.Column<"string", string | null, string | null>;
-    fingerprint_hash: fumadb_schema0.Column<"string", string | null, string | null>;
-    metadata: fumadb_schema0.Column<"json", unknown, unknown>;
-  }, {}>;
-}>[]>;
-type HotUpdaterClient = InferFumaDB<typeof HotUpdaterDB>;
-type Migrator = ReturnType<HotUpdaterClient["createMigrator"]>;
-//#endregion
-export { HotUpdaterClient, HotUpdaterDB, Migrator };