@hot-updater/server 0.21.0

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

@@ -0,0 +1,341 @@
+import { PGlite } from "@electric-sql/pglite";
+import type { Bundle } from "@hot-updater/core";
+import { NIL_UUID } from "@hot-updater/core";
+import { kyselyAdapter } from "@hot-updater/server/adapters/kysely";
+import { standaloneRepository } from "@hot-updater/standalone";
+import { Kysely } from "kysely";
+import { PGliteDialect } from "kysely-pglite-dialect";
+import { HttpResponse, http } from "msw";
+import { setupServer } from "msw/node";
+import { afterAll, afterEach, beforeAll, describe, expect, it } from "vitest";
+import { hotUpdater } from "./db";
+
+/**
+ * Integration tests between @hot-updater/server handler and @hot-updater/standalone repository
+ *
+ * This test suite verifies real-world compatibility by:
+ * 1. Using actual standaloneRepository (not mocks)
+ * 2. Using actual handler (not mocks)
+ * 3. Simulating HTTP communication via MSW
+ * 4. Testing end-to-end flows: standalone → HTTP → handler → database
+ */
+
+// Create in-memory database for testing
+const db = new PGlite();
+const kysely = new Kysely({ dialect: new PGliteDialect(db) });
+
+// Create handler API with in-memory DB
+const api = hotUpdater({
+  database: kyselyAdapter({
+    db: kysely,
+    provider: "postgresql",
+  }),
+  basePath: "/hot-updater",
+});
+
+// Setup MSW server to intercept HTTP requests
+const baseUrl = "http://localhost:3000";
+const server = setupServer();
+
+beforeAll(async () => {
+  // Initialize database
+  const migrator = api.createMigrator();
+  const result = await migrator.migrateToLatest({
+    mode: "from-schema",
+    updateSettings: true,
+  });
+  await result.execute();
+
+  // Start MSW server
+  server.listen({ onUnhandledRequest: "error" });
+
+  // Route all requests to our handler
+  const handleRequest = async (request: Request) => {
+    const response = await api.handler(request);
+    const data = (await response.json()) as Record<string, unknown>;
+    return HttpResponse.json(data, {
+      status: response.status,
+      headers: response.headers,
+    });
+  };
+
+  server.use(
+    // Specific routes
+    http.get(`${baseUrl}/hot-updater/bundles`, ({ request }) =>
+      handleRequest(request),
+    ),
+    http.get(`${baseUrl}/hot-updater/bundles/:id`, ({ request }) =>
+      handleRequest(request),
+    ),
+    http.post(`${baseUrl}/hot-updater/bundles`, ({ request }) =>
+      handleRequest(request),
+    ),
+    http.delete(`${baseUrl}/hot-updater/bundles/:id`, ({ request }) =>
+      handleRequest(request),
+    ),
+  );
+});
+
+afterEach(async () => {
+  // Clean up database after each test
+  await db.exec("DELETE FROM bundles");
+});
+
+afterAll(async () => {
+  server.close();
+  await kysely.destroy();
+  await db.close();
+});
+
+const createTestBundle = (overrides?: Partial<Bundle>): Bundle => ({
+  id: NIL_UUID,
+  platform: "ios",
+  channel: "production",
+  enabled: true,
+  shouldForceUpdate: false,
+  fileHash: "test-hash",
+  gitCommitHash: null,
+  message: null,
+  targetAppVersion: "*",
+  storageUri: "test://storage",
+  fingerprintHash: null,
+  ...overrides,
+});
+
+describe("Handler <-> Standalone Repository Integration", () => {
+  it("Real integration: appendBundle + commitBundle → handler POST /bundles", async () => {
+    // Create standalone repository pointing to our test server
+    const repo = standaloneRepository({
+      baseUrl: `${baseUrl}/hot-updater`,
+    })({ cwd: process.cwd() });
+
+    const bundle = createTestBundle({
+      id: "integration-test-1",
+      fileHash: "integration-hash-1",
+    });
+
+    // Standalone repository operations
+    await repo.appendBundle(bundle);
+    await repo.commitBundle(); // Triggers actual commit
+
+    // Verify via handler that bundle was created
+    const request = new Request(
+      `${baseUrl}/hot-updater/bundles/integration-test-1`,
+      {
+        method: "GET",
+      },
+    );
+
+    const response = await api.handler(request);
+    expect(response.status).toBe(200);
+
+    const retrieved = (await response.json()) as Bundle;
+    expect(retrieved.id).toBe("integration-test-1");
+    expect(retrieved.fileHash).toBe("integration-hash-1");
+  });
+
+  it("Real integration: getBundleById → handler GET /bundles/:id", async () => {
+    // First, create a bundle directly via handler
+    const bundle = createTestBundle({
+      id: "get-test-1",
+      fileHash: "get-hash-1",
+    });
+
+    await api.insertBundle(bundle);
+
+    // Create standalone repository
+    const repo = standaloneRepository({
+      baseUrl: `${baseUrl}/hot-updater`,
+    })({ cwd: process.cwd() });
+
+    // Use standalone repository to retrieve
+    const retrieved = await repo.getBundleById("get-test-1");
+
+    expect(retrieved).toBeTruthy();
+    expect(retrieved?.id).toBe("get-test-1");
+    expect(retrieved?.fileHash).toBe("get-hash-1");
+  });
+
+  it("Real integration: deleteBundle + commitBundle → handler DELETE /bundles/:id", async () => {
+    // Create a bundle via handler
+    const bundle = createTestBundle({
+      id: "delete-test-1",
+      fileHash: "delete-hash-1",
+    });
+
+    await api.insertBundle(bundle);
+
+    // Verify it exists
+    const beforeDelete = await api.getBundleById("delete-test-1");
+    expect(beforeDelete).toBeTruthy();
+
+    // Create standalone repository
+    const repo = standaloneRepository({
+      baseUrl: `${baseUrl}/hot-updater`,
+    })({ cwd: process.cwd() });
+
+    // Delete via standalone repository
+    await repo.deleteBundle(bundle);
+    await repo.commitBundle();
+
+    // Verify it was deleted
+    const afterDelete = await api.getBundleById("delete-test-1");
+    expect(afterDelete).toBeNull();
+  });
+
+  it("Real integration: getBundles → handler GET /bundles", async () => {
+    // Create multiple bundles
+    await api.insertBundle(
+      createTestBundle({ id: "list-1", channel: "production" }),
+    );
+    await api.insertBundle(
+      createTestBundle({ id: "list-2", channel: "production" }),
+    );
+    await api.insertBundle(
+      createTestBundle({ id: "list-3", channel: "staging" }),
+    );
+
+    // Create standalone repository
+    const repo = standaloneRepository({
+      baseUrl: `${baseUrl}/hot-updater`,
+    })({ cwd: process.cwd() });
+
+    // Get all bundles
+    const result = await repo.getBundles({ limit: 50, offset: 0 });
+
+    expect(result.data).toHaveLength(3);
+    expect(result.pagination.total).toBe(3);
+
+    // Filter by channel
+    const prodResult = await repo.getBundles({
+      where: { channel: "production" },
+      limit: 50,
+      offset: 0,
+    });
+
+    expect(prodResult.data).toHaveLength(2);
+  });
+
+  it("Full E2E: create → retrieve → update → delete via standalone", async () => {
+    const repo = standaloneRepository({
+      baseUrl: `${baseUrl}/hot-updater`,
+    })({ cwd: process.cwd() });
+
+    // Step 1: Create bundle via standalone
+    const bundle = createTestBundle({
+      id: "e2e-bundle",
+      fileHash: "e2e-hash",
+      enabled: true,
+    });
+
+    await repo.appendBundle(bundle);
+    await repo.commitBundle();
+
+    // Step 2: Retrieve via standalone
+    const retrieved = await repo.getBundleById("e2e-bundle");
+    expect(retrieved).toBeTruthy();
+    expect(retrieved?.enabled).toBe(true);
+
+    // Step 3: Update via standalone
+    await repo.updateBundle("e2e-bundle", { enabled: false });
+    await repo.commitBundle();
+
+    // Verify update
+    const updated = await repo.getBundleById("e2e-bundle");
+    expect(updated?.enabled).toBe(false);
+
+    // Step 4: Delete via standalone
+    await repo.deleteBundle(bundle);
+    await repo.commitBundle();
+
+    // Verify deletion
+    const deleted = await repo.getBundleById("e2e-bundle");
+    expect(deleted).toBeNull();
+  });
+
+  it("Multiple bundles in single commit (standalone sends array)", async () => {
+    const repo = standaloneRepository({
+      baseUrl: `${baseUrl}/hot-updater`,
+    })({ cwd: process.cwd() });
+
+    // Append multiple bundles
+    await repo.appendBundle(createTestBundle({ id: "batch-1" }));
+    await repo.appendBundle(createTestBundle({ id: "batch-2" }));
+    await repo.appendBundle(createTestBundle({ id: "batch-3" }));
+
+    // Commit all at once (standalone sends array in POST)
+    await repo.commitBundle();
+
+    // Verify all were created
+    const bundle1 = await api.getBundleById("batch-1");
+    const bundle2 = await api.getBundleById("batch-2");
+    const bundle3 = await api.getBundleById("batch-3");
+
+    expect(bundle1).toBeTruthy();
+    expect(bundle2).toBeTruthy();
+    expect(bundle3).toBeTruthy();
+  });
+
+  it("Works with custom basePath configuration", async () => {
+    // Create handler with custom basePath
+    const customApi = hotUpdater({
+      database: kyselyAdapter({
+        db: kysely,
+        provider: "postgresql",
+      }),
+      basePath: "/api/v2",
+    });
+
+    // Setup MSW for custom basePath
+    server.use(
+      http.get(`${baseUrl}/api/v2/*`, async ({ request }) => {
+        const response = await customApi.handler(request);
+        return HttpResponse.json(
+          (await response.json()) as Record<string, unknown>,
+          {
+            status: response.status,
+          },
+        );
+      }),
+      http.post(`${baseUrl}/api/v2/*`, async ({ request }) => {
+        const response = await customApi.handler(request);
+        return HttpResponse.json(
+          (await response.json()) as Record<string, unknown>,
+          {
+            status: response.status,
+          },
+        );
+      }),
+    );
+
+    // Create standalone repository with matching basePath
+    const repo = standaloneRepository({
+      baseUrl: `${baseUrl}/api/v2`,
+    })({ cwd: process.cwd() });
+
+    // Test create and retrieve
+    const bundle = createTestBundle({
+      id: "custom-path-test",
+      fileHash: "custom-hash",
+    });
+
+    await repo.appendBundle(bundle);
+    await repo.commitBundle();
+
+    const retrieved = await repo.getBundleById("custom-path-test");
+    expect(retrieved).toBeTruthy();
+    expect(retrieved?.fileHash).toBe("custom-hash");
+  });
+
+  it("Handler returns 404 when bundle not found (standalone handles gracefully)", async () => {
+    const repo = standaloneRepository({
+      baseUrl: `${baseUrl}/hot-updater`,
+    })({ cwd: process.cwd() });
+
+    // Try to get non-existent bundle
+    const result = await repo.getBundleById("non-existent-bundle");
+
+    // Standalone should return null gracefully
+    expect(result).toBeNull();
+  });
+});

package/src/handler.ts

@@ -0,0 +1,231 @@
+import type {
+  AppUpdateInfo,
+  AppVersionGetBundlesArgs,
+  Bundle,
+  FingerprintGetBundlesArgs,
+} from "@hot-updater/core";
+import type { PaginationInfo } from "./types";
+
+// Narrow API surface needed by the handler to avoid circular types
+export interface HandlerAPI {
+  getAppUpdateInfo: (
+    args: AppVersionGetBundlesArgs | FingerprintGetBundlesArgs,
+  ) => Promise<AppUpdateInfo | null>;
+  getBundleById: (id: string) => Promise<Bundle | null>;
+  getBundles: (options: {
+    where?: { channel?: string; platform?: string };
+    limit: number;
+    offset: number;
+  }) => Promise<{ data: Bundle[]; pagination: PaginationInfo }>;
+  insertBundle: (bundle: Bundle) => Promise<void>;
+  deleteBundleById: (bundleId: string) => Promise<void>;
+  getChannels: () => Promise<string[]>;
+}
+
+export interface HandlerOptions {
+  /**
+   * Base path for all routes
+   * @default "/api"
+   */
+  basePath?: string;
+}
+
+/**
+ * Creates a Web Standard Request handler for Hot Updater API
+ * This handler is framework-agnostic and works with any framework
+ * that supports Web Standard Request/Response (Hono, Elysia, etc.)
+ */
+export function createHandler(
+  api: HandlerAPI,
+  options: HandlerOptions = {},
+): (request: Request) => Promise<Response> {
+  const basePath = options.basePath ?? "/api";
+
+  return async (request: Request): Promise<Response> => {
+    try {
+      const url = new URL(request.url);
+      const path = url.pathname;
+      const method = request.method;
+
+      // Remove base path from pathname
+      const routePath = path.startsWith(basePath)
+        ? 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" },
+        });
+      }
+
+      // 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,
+          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,
+          headers: { "Content-Type": "application/json" },
+        });
+      }
+
+      // 404 Not Found
+      return new Response(JSON.stringify({ error: "Not found" }), {
+        status: 404,
+        headers: { "Content-Type": "application/json" },
+      });
+    } catch (error) {
+      console.error("Hot Updater handler error:", error);
+      return new Response(
+        JSON.stringify({
+          error: "Internal server error",
+          message: error instanceof Error ? error.message : "Unknown error",
+        }),
+        {
+          status: 500,
+          headers: { "Content-Type": "application/json" },
+        },
+      );
+    }
+  };
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from "./db";
+export * from "./handler";
+export * from "./types";

package/src/schema/v1.ts

@@ -0,0 +1,22 @@
+import { column, idColumn, schema, table } from "fumadb/schema";
+
+export const v1 = schema({
+  version: "1.0.0",
+  tables: {
+    bundles: table("bundles", {
+      id: idColumn("id", "varchar(255)").defaultTo$("auto"),
+      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"),
+    }),
+  },
+  relations: {},
+});

package/src/types/index.ts

@@ -0,0 +1,21 @@
+import type { Bundle } from "@hot-updater/core";
+
+export type { Bundle } from "@hot-updater/core";
+
+export interface PaginationInfo {
+  total: number;
+  hasNextPage: boolean;
+  hasPreviousPage: boolean;
+  currentPage: number;
+  totalPages: number;
+}
+
+export interface PaginationOptions {
+  limit: number;
+  offset: number;
+}
+
+export interface PaginatedResult {
+  data: Bundle[];
+  pagination: PaginationInfo;
+}