@hot-updater/server 0.21.5 → 0.21.7

package/src/handler.ts

@@ -4,6 +4,7 @@ import type {
   Bundle,
   FingerprintGetBundlesArgs,
 } from "@hot-updater/core";
+import { addRoute, createRouter, findRoute } from "rou3";
 import type { PaginationInfo } from "./types";
 
 // Narrow API surface needed by the handler to avoid circular types
@@ -30,6 +31,139 @@ export interface HandlerOptions {
   basePath?: string;
 }
 
+type RouteHandler = (
+  params: Record<string, string>,
+  request: Request,
+  api: HandlerAPI,
+) => Promise<Response>;
+
+// Route handlers
+const handleUpdate: RouteHandler = async (_params, request, api) => {
+  const body = (await request.json()) as
+    | AppVersionGetBundlesArgs
+    | FingerprintGetBundlesArgs;
+  const updateInfo = await api.getAppUpdateInfo(body);
+
+  return new Response(JSON.stringify(updateInfo), {
+    status: 200,
+    headers: { "Content-Type": "application/json" },
+  });
+};
+
+const handleFingerprintUpdate: RouteHandler = async (params, _request, api) => {
+  const updateInfo = await api.getAppUpdateInfo({
+    _updateStrategy: "fingerprint",
+    platform: params.platform as "ios" | "android",
+    fingerprintHash: params.fingerprintHash,
+    channel: params.channel,
+    minBundleId: params.minBundleId,
+    bundleId: params.bundleId,
+  });
+
+  return new Response(JSON.stringify(updateInfo), {
+    status: 200,
+    headers: { "Content-Type": "application/json" },
+  });
+};
+
+const handleAppVersionUpdate: RouteHandler = async (params, _request, api) => {
+  const updateInfo = await api.getAppUpdateInfo({
+    _updateStrategy: "appVersion",
+    platform: params.platform as "ios" | "android",
+    appVersion: params.appVersion,
+    channel: params.channel,
+    minBundleId: params.minBundleId,
+    bundleId: params.bundleId,
+  });
+
+  return new Response(JSON.stringify(updateInfo), {
+    status: 200,
+    headers: { "Content-Type": "application/json" },
+  });
+};
+
+const handleGetBundle: RouteHandler = async (params, _request, api) => {
+  const bundle = await api.getBundleById(params.id);
+
+  if (!bundle) {
+    return new Response(JSON.stringify({ error: "Bundle not found" }), {
+      status: 404,
+      headers: { "Content-Type": "application/json" },
+    });
+  }
+
+  return new Response(JSON.stringify(bundle), {
+    status: 200,
+    headers: { "Content-Type": "application/json" },
+  });
+};
+
+const handleGetBundles: RouteHandler = async (_params, request, api) => {
+  const url = new URL(request.url);
+  const channel = url.searchParams.get("channel") ?? undefined;
+  const platform = url.searchParams.get("platform") ?? undefined;
+  const limit = Number(url.searchParams.get("limit")) || 50;
+  const offset = Number(url.searchParams.get("offset")) || 0;
+
+  const result = await api.getBundles({
+    where: {
+      ...(channel && { channel }),
+      ...(platform && { platform }),
+    },
+    limit,
+    offset,
+  });
+
+  return new Response(JSON.stringify(result.data), {
+    status: 200,
+    headers: { "Content-Type": "application/json" },
+  });
+};
+
+const handleCreateBundles: RouteHandler = async (_params, request, api) => {
+  const body = await request.json();
+  const bundles = Array.isArray(body) ? body : [body];
+
+  for (const bundle of bundles) {
+    await api.insertBundle(bundle as Bundle);
+  }
+
+  return new Response(JSON.stringify({ success: true }), {
+    status: 201,
+    headers: { "Content-Type": "application/json" },
+  });
+};
+
+const handleDeleteBundle: RouteHandler = async (params, _request, api) => {
+  await api.deleteBundleById(params.id);
+
+  return new Response(JSON.stringify({ success: true }), {
+    status: 200,
+    headers: { "Content-Type": "application/json" },
+  });
+};
+
+const handleGetChannels: RouteHandler = async (_params, _request, api) => {
+  const channels = await api.getChannels();
+
+  return new Response(JSON.stringify({ channels }), {
+    status: 200,
+    headers: { "Content-Type": "application/json" },
+  });
+};
+
+// Route handlers map
+const routes: Record<string, RouteHandler> = {
+  update: handleUpdate,
+  fingerprintUpdate: handleFingerprintUpdate,
+  appVersionUpdate: handleAppVersionUpdate,
+  getBundle: handleGetBundle,
+  getBundles: handleGetBundles,
+  createBundles: handleCreateBundles,
+  deleteBundle: handleDeleteBundle,
+  getChannels: handleGetChannels,
+};
+
 /**
  * Creates a Web Standard Request handler for Hot Updater API
  * This handler is framework-agnostic and works with any framework
@@ -41,6 +175,29 @@ export function createHandler(
 ): (request: Request) => Promise<Response> {
   const basePath = options.basePath ?? "/api";
 
+  // Create and configure router
+  const router = createRouter();
+
+  // Register routes
+  addRoute(router, "POST", "/update", "update");
+  addRoute(
+    router,
+    "GET",
+    "/fingerprint/:platform/:fingerprintHash/:channel/:minBundleId/:bundleId",
+    "fingerprintUpdate",
+  );
+  addRoute(
+    router,
+    "GET",
+    "/app-version/:platform/:appVersion/:channel/:minBundleId/:bundleId",
+    "appVersionUpdate",
+  );
+  addRoute(router, "GET", "/bundles/:id", "getBundle");
+  addRoute(router, "GET", "/bundles", "getBundles");
+  addRoute(router, "POST", "/bundles", "createBundles");
+  addRoute(router, "DELETE", "/bundles/:id", "deleteBundle");
+  addRoute(router, "GET", "/channels", "getChannels");
+
   return async (request: Request): Promise<Response> => {
     try {
       const url = new URL(request.url);
@@ -52,168 +209,26 @@ export function createHandler(
         ? path.slice(basePath.length)
         : path;
 
-      // POST /api/update - Client checks for updates
-      if (routePath === "/update" && method === "POST") {
-        const body = (await request.json()) as
-          | AppVersionGetBundlesArgs
-          | FingerprintGetBundlesArgs;
-        const updateInfo = await api.getAppUpdateInfo(body);
-
-        if (!updateInfo) {
-          return new Response(JSON.stringify(null), {
-            status: 200,
-            headers: { "Content-Type": "application/json" },
-          });
-        }
-
-        return new Response(JSON.stringify(updateInfo), {
-          status: 200,
-          headers: { "Content-Type": "application/json" },
-        });
-      }
+      // Find matching route
+      const match = findRoute(router, method, routePath);
 
-      // GET /api/fingerprint/:platform/:fingerprintHash/:channel/:minBundleId/:bundleId
-      const fingerprintMatch = routePath.match(
-        /^\/fingerprint\/([^/]+)\/([^/]+)\/([^/]+)\/([^/]+)\/([^/]+)$/,
-      );
-      if (fingerprintMatch && method === "GET") {
-        const [, platform, fingerprintHash, channel, minBundleId, bundleId] =
-          fingerprintMatch;
-
-        const updateInfo = await api.getAppUpdateInfo({
-          _updateStrategy: "fingerprint",
-          platform: platform as "ios" | "android",
-          fingerprintHash,
-          channel,
-          minBundleId,
-          bundleId,
-        });
-
-        if (!updateInfo) {
-          return new Response(JSON.stringify(null), {
-            status: 200,
-            headers: { "Content-Type": "application/json" },
-          });
-        }
-
-        return new Response(JSON.stringify(updateInfo), {
-          status: 200,
+      if (!match) {
+        return new Response(JSON.stringify({ error: "Not found" }), {
+          status: 404,
           headers: { "Content-Type": "application/json" },
         });
       }
 
-      // GET /api/app-version/:platform/:appVersion/:channel/:minBundleId/:bundleId
-      const appVersionMatch = routePath.match(
-        /^\/app-version\/([^/]+)\/([^/]+)\/([^/]+)\/([^/]+)\/([^/]+)$/,
-      );
-      if (appVersionMatch && method === "GET") {
-        const [, platform, appVersion, channel, minBundleId, bundleId] =
-          appVersionMatch;
-
-        const updateInfo = await api.getAppUpdateInfo({
-          _updateStrategy: "appVersion",
-          platform: platform as "ios" | "android",
-          appVersion,
-          channel,
-          minBundleId,
-          bundleId,
-        });
-
-        if (!updateInfo) {
-          return new Response(JSON.stringify(null), {
-            status: 200,
-            headers: { "Content-Type": "application/json" },
-          });
-        }
-
-        return new Response(JSON.stringify(updateInfo), {
-          status: 200,
-          headers: { "Content-Type": "application/json" },
-        });
-      }
-
-      // GET /api/bundles/:id - Get single bundle
-      const getBundleMatch = routePath.match(/^\/bundles\/([^/]+)$/);
-      if (getBundleMatch && method === "GET") {
-        const id = getBundleMatch[1];
-        const bundle = await api.getBundleById(id);
-
-        if (!bundle) {
-          return new Response(JSON.stringify({ error: "Bundle not found" }), {
-            status: 404,
-            headers: { "Content-Type": "application/json" },
-          });
-        }
-
-        return new Response(JSON.stringify(bundle), {
-          status: 200,
-          headers: { "Content-Type": "application/json" },
-        });
-      }
-
-      // GET /api/bundles - List bundles
-      if (routePath === "/bundles" && method === "GET") {
-        const channel = url.searchParams.get("channel") ?? undefined;
-        const platform = url.searchParams.get("platform") ?? undefined;
-        const limit = Number(url.searchParams.get("limit")) || 50;
-        const offset = Number(url.searchParams.get("offset")) || 0;
-
-        const result = await api.getBundles({
-          where: {
-            ...(channel && { channel }),
-            ...(platform && { platform }),
-          },
-          limit,
-          offset,
-        });
-
-        return new Response(JSON.stringify(result.data), {
-          status: 200,
-          headers: { "Content-Type": "application/json" },
-        });
-      }
-
-      // POST /api/bundles - Create new bundle(s)
-      if (routePath === "/bundles" && method === "POST") {
-        const body = await request.json();
-        const bundles = Array.isArray(body) ? body : [body];
-
-        for (const bundle of bundles) {
-          await api.insertBundle(bundle as Bundle);
-        }
-
-        return new Response(JSON.stringify({ success: true }), {
-          status: 201,
-          headers: { "Content-Type": "application/json" },
-        });
-      }
-
-      // DELETE /api/bundles/:id - Delete bundle
-      if (routePath.startsWith("/bundles/") && method === "DELETE") {
-        const id = routePath.slice("/bundles/".length);
-        await api.deleteBundleById(id);
-
-        return new Response(JSON.stringify({ success: true }), {
-          status: 200,
-          headers: { "Content-Type": "application/json" },
-        });
-      }
-
-      // GET /api/channels - List all channels
-      if (routePath === "/channels" && method === "GET") {
-        const channels = await api.getChannels();
-
-        return new Response(JSON.stringify({ channels }), {
-          status: 200,
+      // Get handler and execute
+      const handler = routes[match.data as string];
+      if (!handler) {
+        return new Response(JSON.stringify({ error: "Handler not found" }), {
+          status: 500,
           headers: { "Content-Type": "application/json" },
         });
       }
 
-      // 404 Not Found
-      return new Response(JSON.stringify({ error: "Not found" }), {
-        status: 404,
-        headers: { "Content-Type": "application/json" },
-      });
+      return await handler(match.params || {}, request, api);
     } catch (error) {
       console.error("Hot Updater handler error:", error);
       return new Response(

package/src/node.ts

@@ -0,0 +1,104 @@
+import type { HotUpdaterAPI } from "./types";
+
+/**
+ * Node.js request/response types (compatible with Express, Connect, etc.)
+ */
+interface NodeRequest {
+  method?: string;
+  url?: string;
+  headers: Record<string, string | string[] | undefined>;
+  body?: unknown;
+  protocol?: string;
+  get?(name: string): string | undefined;
+  [key: string]: unknown;
+}
+
+interface NodeResponse {
+  status(code: number): NodeResponse;
+  setHeader(name: string, value: string | string[]): void;
+  send(body: string): void;
+  end(): void;
+  [key: string]: unknown;
+}
+
+/**
+ * Converts a Hot Updater handler to a Node.js-compatible middleware
+ * Works with Express, Connect, and other frameworks using Node.js req/res
+ *
+ * @example
+ * ```typescript
+ * import { toNodeHandler } from "@hot-updater/server/node";
+ * import express from "express";
+ *
+ * const app = express();
+ *
+ * // Mount middleware
+ * app.use(express.json());
+ *
+ * // Mount hot-updater handler
+ * app.all("/hot-updater/*", toNodeHandler(hotUpdater));
+ * ```
+ */
+export function toNodeHandler(
+  hotUpdater: HotUpdaterAPI,
+): (req: any, res: any, next?: any) => Promise<void> {
+  return async (req: NodeRequest, res: NodeResponse) => {
+    try {
+      // Build full URL
+      const protocol = req.protocol || "http";
+      const host = req.get?.("host") || "localhost";
+      const url = `${protocol}://${host}${req.url || "/"}`;
+
+      // Convert headers to Web Headers
+      const headers = new Headers();
+      for (const [key, value] of Object.entries(req.headers)) {
+        if (value) {
+          headers.set(key, Array.isArray(value) ? value.join(", ") : value);
+        }
+      }
+
+      // Handle request body
+      let body: string | undefined;
+      if (
+        req.method &&
+        req.method !== "GET" &&
+        req.method !== "HEAD" &&
+        req.body
+      ) {
+        // If body is already parsed (by express.json()), stringify it
+        body = JSON.stringify(req.body);
+      }
+
+      // Create Web Request
+      const webRequest = new globalThis.Request(url, {
+        method: req.method || "GET",
+        headers,
+        body,
+      });
+
+      // Call hot-updater handler
+      const response = await hotUpdater.handler(webRequest);
+
+      // Set status code
+      res.status(response.status);
+
+      // Set headers
+      response.headers.forEach((value, key) => {
+        res.setHeader(key, value);
+      });
+
+      // Send response body
+      const text = await response.text();
+      if (text) {
+        res.send(text);
+      } else {
+        res.end();
+      }
+    } catch (error) {
+      // Handle errors gracefully
+      console.error("Hot Updater handler error:", error);
+      res.status(500);
+      res.send("Internal Server Error");
+    }
+  };
+}

package/src/schema/{v1.ts → v0_21_0.ts}

@@ -1,10 +1,10 @@
 import { column, idColumn, schema, table } from "fumadb/schema";
 
-export const v1 = schema({
-  version: "1.0.0",
+export const v0_21_0 = schema({
+  version: "0.21.0",
   tables: {
     bundles: table("bundles", {
-      id: idColumn("id", "varchar(255)").defaultTo$("auto"),
+      id: idColumn("id", "uuid"),
       platform: column("platform", "string"),
       should_force_update: column("should_force_update", "bool"),
       enabled: column("enabled", "bool"),

package/src/types/index.ts

@@ -1,6 +1,7 @@
 import type { Bundle } from "@hot-updater/core";
 
 export type { Bundle } from "@hot-updater/core";
+export type { HotUpdaterAPI } from "../db";
 
 export interface PaginationInfo {
   total: number;

package/dist/adapters/typeorm.cjs

@@ -1,9 +0,0 @@
-
-
-var fumadb_adapters_typeorm = require("fumadb/adapters/typeorm");
-Object.keys(fumadb_adapters_typeorm).forEach(function (k) {
-  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
-    enumerable: true,
-    get: function () { return fumadb_adapters_typeorm[k]; }
-  });
-});

package/dist/adapters/typeorm.d.cts

@@ -1 +0,0 @@
-export * from "fumadb/adapters/typeorm";

package/dist/adapters/typeorm.d.ts

@@ -1 +0,0 @@
-export * from "fumadb/adapters/typeorm";

package/dist/adapters/typeorm.js

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

package/src/adapters/typeorm.ts

@@ -1 +0,0 @@
-export * from "fumadb/adapters/typeorm";