@hot-updater/console 1.0.0-rc.2 → 1.0.0-rc.20

package/src/lib/api-rpc.ts

@@ -1,27 +1,24 @@
 import {
-  DatabasePluginInputError,
-  type Bundle,
-  type ChannelDeleteInput,
-  type ChannelInsertInput,
-  type DatabaseBundleQueryOptions,
-  deleteRelease as deleteReleaseMutation,
-  preflightReleasePolicy,
-  promoteRelease as promoteReleaseMutation,
+  type ChannelDeleteResult,
+  type ChannelRow,
+  type ReleaseFilter,
   type ReleasePolicyPatch,
-  updateReleasePolicy,
+  rowToBundle,
 } from "@hot-updater/plugin-core";
 import { createServerFn } from "@tanstack/react-start";
 
+import { consoleAccess } from "./console-access";
 import { DEFAULT_PAGE_LIMIT } from "./constants";
 import { withPublicBundleMutationErrors } from "./public-bundle-error";
-import { listReleases } from "./server/listReleases";
+import { listReleases, readReleaseFilter } from "./server/listReleases";
 import { addReleaseReachability } from "./server/releaseReachability";
 
 type GetBundlesInput = {
   platform?: "ios" | "android";
-  page?: number;
-  limit?: string;
+  limit?: number;
+  /** Bundles older than this id: the next page. */
   after?: string;
+  /** Bundles newer than this id: the previous page. */
   before?: string;
 };
 
@@ -46,15 +43,13 @@ type DeleteBundlesInput = {
 };
 
 type GetReleasesInput = {
-  afterReleaseId?: string;
+  /** One of the filter sets the release indexes serve. */
+  filter?: ReleaseFilter;
+  /** Releases older than this id: the next page. */
   beforeReleaseId?: string;
-  bundleId?: string;
-  channelId?: string;
-  enabled?: boolean;
-  platform?: "ios" | "android";
+  /** Releases newer than this id: the previous page. */
+  afterReleaseId?: string;
   limit?: number;
-  page?: number;
-  targetAppVersion?: string;
 };
 
 type ReleaseMutationInput = {
@@ -68,78 +63,78 @@ type DeleteReleaseInput = {
   releaseId: string;
 };
 
+const MAX_PAGE_LIMIT = 100;
+
+const pageLimit = (limit: number | undefined) => {
+  const value = limit ?? DEFAULT_PAGE_LIMIT;
+  if (!Number.isSafeInteger(value) || value < 1 || value > MAX_PAGE_LIMIT) {
+    throw new Error(`limit must be between 1 and ${MAX_PAGE_LIMIT}.`);
+  }
+  return value;
+};
+
+const prepare = async () => {
+  const { prepareConfig } = await import("./server/config.server");
+  return prepareConfig();
+};
+
 export const getReleases = createServerFn({ method: "GET" })
-  .inputValidator((input: GetReleasesInput | undefined) => input)
+  .middleware([consoleAccess])
+  .validator((input: GetReleasesInput | undefined) => ({
+    filter: readReleaseFilter(input?.filter),
+    ...(input?.afterReleaseId === undefined
+      ? {}
+      : { afterReleaseId: input.afterReleaseId }),
+    ...(input?.beforeReleaseId === undefined
+      ? {}
+      : { beforeReleaseId: input.beforeReleaseId }),
+    limit: pageLimit(input?.limit),
+  }))
   .handler(async ({ data }) => {
-    const { prepareConfig } = await import("./server/config.server");
-    const { config } = await prepareConfig();
-    const result = await listReleases(config.database.models.releases, {
-      ...(data?.afterReleaseId === undefined
-        ? {}
-        : { afterReleaseId: data.afterReleaseId }),
-      ...(data?.beforeReleaseId === undefined
-        ? {}
-        : { beforeReleaseId: data.beforeReleaseId }),
-      ...(data?.bundleId === undefined ? {} : { bundleId: data.bundleId }),
-      ...(data?.channelId === undefined ? {} : { channelId: data.channelId }),
-      ...(data?.enabled === undefined ? {} : { enabled: data.enabled }),
-      ...(data?.page === undefined ? {} : { page: data.page }),
-      ...(data?.platform === undefined ? {} : { platform: data.platform }),
-      ...(data?.targetAppVersion === undefined
-        ? {}
-        : { targetAppVersion: data.targetAppVersion }),
-      limit: data?.limit ?? DEFAULT_PAGE_LIMIT,
-    });
-    const releases = await addReleaseReachability(
-      config.database.models.releaseCatalogs,
-      result.data,
-    );
+    const { core } = await prepare();
+    const result = await listReleases(core, data);
     return {
       ...result,
-      data: releases,
+      data: await addReleaseReachability(core, result.data),
     };
   });
 
 export const getRelease = createServerFn({ method: "GET" })
-  .inputValidator((input: { releaseId: string }) => input)
-  .handler(async ({ data }) => {
-    const { prepareConfig } = await import("./server/config.server");
-    const { config } = await prepareConfig();
-    return config.database.models.releases.findById(data.releaseId);
-  });
+  .middleware([consoleAccess])
+  .validator((input: { releaseId: string }) => input)
+  .handler(async ({ data }) =>
+    (await prepare()).core.getRelease(data.releaseId),
+  );
 
 export const updateRelease = createServerFn({ method: "POST" })
-  .inputValidator((input: ReleaseMutationInput) => input)
+  .middleware([consoleAccess])
+  .validator((input: ReleaseMutationInput) => input)
   .handler(async ({ data }) => {
-    const { prepareConfig } = await import("./server/config.server");
-    const { config } = await prepareConfig();
-    return withPublicBundleMutationErrors(() =>
-      updateReleasePolicy({ database: config.database, ...data }),
-    );
+    const { core } = await prepare();
+    return withPublicBundleMutationErrors(() => core.updateReleasePolicy(data));
   });
 
 export const preflightRelease = createServerFn({ method: "POST" })
-  .inputValidator((input: ReleaseMutationInput) => input)
+  .middleware([consoleAccess])
+  .validator((input: ReleaseMutationInput) => input)
   .handler(async ({ data }) => {
-    const { prepareConfig } = await import("./server/config.server");
-    const { config } = await prepareConfig();
+    const { core } = await prepare();
     return withPublicBundleMutationErrors(() =>
-      preflightReleasePolicy({ database: config.database, ...data }),
+      core.preflightReleasePolicy(data),
     );
   });
 
 export const deleteRelease = createServerFn({ method: "POST" })
-  .inputValidator((input: DeleteReleaseInput) => input)
+  .middleware([consoleAccess])
+  .validator((input: DeleteReleaseInput) => input)
   .handler(async ({ data }) => {
-    const { prepareConfig } = await import("./server/config.server");
-    const { config } = await prepareConfig();
-    return withPublicBundleMutationErrors(() =>
-      deleteReleaseMutation({ database: config.database, ...data }),
-    );
+    const { core } = await prepare();
+    return withPublicBundleMutationErrors(() => core.deleteRelease(data));
   });
 
 export const promoteRelease = createServerFn({ method: "POST" })
-  .inputValidator(
+  .middleware([consoleAccess])
+  .validator(
     (input: {
       action: "copy" | "move";
       expectedRevision?: number;
@@ -148,54 +143,60 @@ export const promoteRelease = createServerFn({ method: "POST" })
     }) => input,
   )
   .handler(async ({ data }) => {
-    const { prepareConfig } = await import("./server/config.server");
-    const { config } = await prepareConfig();
-    return withPublicBundleMutationErrors(() =>
-      promoteReleaseMutation({ database: config.database, ...data }),
-    );
+    const { core } = await prepare();
+    return withPublicBundleMutationErrors(() => core.promoteRelease(data));
   });
 
 export const getReleaseCatalogDiagnostics = createServerFn({ method: "GET" })
-  .inputValidator((input: { scopeKey: string }) => input)
-  .handler(async ({ data }) => {
-    const { prepareConfig } = await import("./server/config.server");
-    const { config } = await prepareConfig();
-    return config.database.models.releaseCatalogs.findByScopeKey(data.scopeKey);
-  });
+  .middleware([consoleAccess])
+  .validator((input: { scopeKey: string }) => input)
+  .handler(async ({ data }) =>
+    (await prepare()).core.getReleaseCatalogRow(data.scopeKey),
+  );
 
 // GET /api/config
-export const getConfig = createServerFn().handler(async () => {
-  try {
-    const { prepareConfig } = await import("./server/config.server");
-    const { config } = await prepareConfig();
-    return { console: config.console };
-  } catch (error) {
-    console.error("Error during config retrieval:", error);
-    throw error;
-  }
-});
+export const getConfig = createServerFn()
+  .middleware([consoleAccess])
+  .handler(async () => {
+    try {
+      const { config } = await prepare();
+      return { console: config.console };
+    } catch (error) {
+      console.error("Error during config retrieval:", error);
+      throw error;
+    }
+  });
 
 // GET /api/channels
-export const getChannels = createServerFn().handler(async () => {
-  try {
-    const { prepareConfig } = await import("./server/config.server");
-    const { databaseClient } = await prepareConfig();
-    const channels = await databaseClient.getChannels();
-    return channels ?? [];
-  } catch (error) {
-    console.error("Error during channel retrieval:", error);
-    throw error;
-  }
-});
+export const getChannels = createServerFn()
+  .middleware([consoleAccess])
+  .handler(async (): Promise<ChannelRow[]> => {
+    try {
+      return await (await prepare()).core.listChannels();
+    } catch (error) {
+      console.error("Error during channel retrieval:", error);
+      throw error;
+    }
+  });
 
 // POST /api/channels
 export const createChannel = createServerFn({ method: "POST" })
-  .inputValidator((input: ChannelInsertInput) => input)
+  .middleware([consoleAccess])
+  .validator((input: { name: string }) => {
+    const name = typeof input?.name === "string" ? input.name.trim() : "";
+    if (name.length === 0) throw new Error("Channel name is required.");
+    return { name };
+  })
   .handler(async ({ data }) => {
     try {
-      const { prepareConfig } = await import("./server/config.server");
-      const { databaseClient } = await prepareConfig();
-      return { data: await databaseClient.insertChannel(data) };
+      const { core } = await prepare();
+      const existing = await core.findChannelByName(data.name);
+      if (existing !== null) {
+        return { data: { row: existing, inserted: false } };
+      }
+      return {
+        data: { row: await core.ensureChannel(data.name), inserted: true },
+      };
     } catch (error) {
       console.error("Error during channel creation:", error);
       throw error;
@@ -204,12 +205,11 @@ export const createChannel = createServerFn({ method: "POST" })
 
 // DELETE /api/channels/:id
 export const deleteChannel = createServerFn({ method: "POST" })
-  .inputValidator((input: ChannelDeleteInput) => input)
-  .handler(async ({ data }) => {
+  .middleware([consoleAccess])
+  .validator((input: { id: string }) => input)
+  .handler(async ({ data }): Promise<{ data: ChannelDeleteResult }> => {
     try {
-      const { prepareConfig } = await import("./server/config.server");
-      const { databaseClient } = await prepareConfig();
-      return { data: await databaseClient.deleteChannel(data) };
+      return { data: await (await prepare()).core.deleteChannel(data.id) };
     } catch (error) {
       console.error("Error during channel deletion:", error);
       throw error;
@@ -217,78 +217,71 @@ export const deleteChannel = createServerFn({ method: "POST" })
   });
 
 // GET /api/config-loaded
-export const getConfigLoaded = createServerFn().handler(async () => {
-  try {
-    const [{ getRequest }, { requireConsoleAccess }] = await Promise.all([
-      import("@tanstack/react-start/server"),
-      import("./server/auth.server"),
-    ]);
-    await requireConsoleAccess(getRequest());
-    const { isConfigLoaded } = await import("./server/config.server");
-    const configLoaded = isConfigLoaded();
-    return { configLoaded };
-  } catch (error) {
-    console.error("Error during config loaded retrieval:", error);
-    throw error;
-  }
-});
+export const getConfigLoaded = createServerFn()
+  .middleware([consoleAccess])
+  .handler(async () => {
+    try {
+      const { isConfigLoaded } = await import("./server/config.server");
+      const configLoaded = isConfigLoaded();
+      return { configLoaded };
+    } catch (error) {
+      console.error("Error during config loaded retrieval:", error);
+      throw error;
+    }
+  });
 
-// GET /api/bundles
+// GET /api/bundles: newest first, one page by key; the total is one counter row.
 export const getBundles = createServerFn({ method: "GET" })
-  .inputValidator((input: GetBundlesInput | undefined) => input)
+  .middleware([consoleAccess])
+  .validator((input: GetBundlesInput | undefined) => {
+    if (input?.after !== undefined && input.before !== undefined) {
+      throw new Error("Page by after or before, not both.");
+    }
+    return {
+      ...(input?.platform === undefined ? {} : { platform: input.platform }),
+      ...(input?.after === undefined ? {} : { after: input.after }),
+      ...(input?.before === undefined ? {} : { before: input.before }),
+      limit: pageLimit(input?.limit),
+    };
+  })
   .handler(async ({ data }) => {
     try {
-      const { prepareConfig } = await import("./server/config.server");
-      const query = {
-        platform: data?.platform ?? undefined,
-        page:
-          typeof data?.page === "number" &&
-          Number.isInteger(data.page) &&
-          data.page > 1
-            ? data.page
-            : undefined,
-        limit: data?.limit ? Number(data.limit) : DEFAULT_PAGE_LIMIT,
-        after: data?.after ?? undefined,
-        before: data?.before ?? undefined,
+      const { core } = await prepare();
+      const platform =
+        data.platform === undefined ? {} : { platform: data.platform };
+      const [page, total] = await Promise.all([
+        data.before === undefined
+          ? core.listBundles({
+              ...platform,
+              order: "desc",
+              limit: data.limit,
+              ...(data.after === undefined ? {} : { after: data.after }),
+            })
+          : core
+              .listBundles({
+                ...platform,
+                order: "asc",
+                limit: data.limit,
+                after: data.before,
+              })
+              .then((rows) => rows.reverse()),
+        core.countBundles(data.platform),
+      ]);
+      const full = page.length === data.limit;
+      const first = page[0]?.bundle.id;
+      const last = page.at(-1)?.bundle.id;
+      return {
+        data: page.map(({ bundle, patches }) => rowToBundle(bundle, patches)),
+        total,
+        // A full page may have more past it; a short one ended the range.
+        ...(last !== undefined && (data.before !== undefined || full)
+          ? { next: last }
+          : {}),
+        ...(first !== undefined &&
+        (data.after !== undefined || (data.before !== undefined && full))
+          ? { previous: first }
+          : {}),
       };
-      if (
-        (query.after !== undefined && query.before !== undefined) ||
-        (query.page !== undefined &&
-          (query.after !== undefined || query.before !== undefined))
-      ) {
-        throw new DatabasePluginInputError("invalid-pagination");
-      }
-      const pagination =
-        query.page !== undefined
-          ? { page: query.page }
-          : query.after !== undefined
-            ? { cursor: { after: query.after } }
-            : query.before !== undefined
-              ? { cursor: { before: query.before } }
-              : {};
-
-      const { databaseClient } = await prepareConfig();
-      const bundleQueryOptions: DatabaseBundleQueryOptions = {
-        where: {
-          platform: query.platform,
-        },
-        limit: query.limit,
-        ...pagination,
-      };
-      const bundles = await databaseClient.getBundles(bundleQueryOptions);
-
-      return (
-        bundles ?? {
-          data: [],
-          pagination: {
-            total: 0,
-            hasNextPage: false,
-            hasPreviousPage: false,
-            currentPage: 1,
-            totalPages: 0,
-          },
-        }
-      );
     } catch (error) {
       console.error("Error during bundle retrieval:", error);
       throw error;
@@ -297,13 +290,14 @@ export const getBundles = createServerFn({ method: "GET" })
 
 // GET /api/bundles/:bundleId
 export const getBundle = createServerFn({ method: "GET" })
-  .inputValidator((input: GetBundleInput) => input)
+  .middleware([consoleAccess])
+  .validator((input: GetBundleInput) => input)
   .handler(async ({ data }) => {
     try {
-      const { prepareConfig } = await import("./server/config.server");
-      const { databaseClient } = await prepareConfig();
-      const bundle = await databaseClient.getBundleById(data.bundleId);
-      return bundle ?? null;
+      const detail = await (await prepare()).core.getBundle(data.bundleId);
+      return detail === null
+        ? null
+        : rowToBundle(detail.bundle, detail.patches);
     } catch (error) {
       console.error("Error during bundle retrieval:", error);
       throw error;
@@ -311,17 +305,13 @@ export const getBundle = createServerFn({ method: "GET" })
   });
 
 export const getBundleChildren = createServerFn({ method: "GET" })
-  .inputValidator((input: GetBundleChildrenInput) => input)
+  .middleware([consoleAccess])
+  .validator((input: GetBundleChildrenInput) => input)
   .handler(async ({ data }) => {
     try {
-      const { prepareConfig } = await import("./server/config.server");
-      const { getBundleChildren: getBundleChildrenWithConfig } =
-        await import("./server/getBundleChildren");
-      const { databaseClient } = await prepareConfig();
-
-      return await getBundleChildrenWithConfig(data, {
-        databaseClient,
-      });
+      const [{ core }, { getBundleChildren: readBundleChildren }] =
+        await Promise.all([prepare(), import("./server/getBundleChildren")]);
+      return await readBundleChildren(core, data.baseBundleId);
     } catch (error) {
       console.error("Error during bundle children retrieval:", error);
       throw error;
@@ -329,50 +319,36 @@ export const getBundleChildren = createServerFn({ method: "GET" })
   });
 
 export const getBundleChildCounts = createServerFn({ method: "GET" })
-  .inputValidator((input: GetBundleChildCountsInput) => input)
-  .handler(async ({ data }) => {
-    try {
-      const { prepareConfig } = await import("./server/config.server");
-      const { getBundleChildCounts: getBundleChildCountsWithConfig } =
-        await import("./server/getBundleChildren");
-      const { databaseClient } = await prepareConfig();
-
-      return await getBundleChildCountsWithConfig(data.bundleIds, {
-        databaseClient,
-      });
-    } catch (error) {
-      console.error("Error during bundle child count retrieval:", error);
-      throw error;
+  .middleware([consoleAccess])
+  .validator((input: GetBundleChildCountsInput) => {
+    if (!Array.isArray(input?.bundleIds) || input.bundleIds.length > 100) {
+      throw new Error("Choose up to 100 bundles.");
     }
-  });
-
-// POST /api/bundles
-export const createBundle = createServerFn({ method: "POST" })
-  .inputValidator((input: Bundle) => input)
+    return input;
+  })
   .handler(async ({ data }) => {
     try {
-      const { prepareConfig } = await import("./server/config.server");
-      const { databaseClient } = await prepareConfig();
-      await databaseClient.insertBundle(data);
-      return { success: true, bundleId: data.id };
+      const [{ core }, { getBundleChildCounts: readBundleChildCounts }] =
+        await Promise.all([prepare(), import("./server/getBundleChildren")]);
+      return await readBundleChildCounts(core, data.bundleIds);
     } catch (error) {
-      console.error("Error during bundle creation:", error);
+      console.error("Error during bundle child count retrieval:", error);
       throw error;
     }
   });
 
 // DELETE /api/bundles/:bundleId
 export const deleteBundle = createServerFn({ method: "POST" })
-  .inputValidator((input: DeleteBundleInput) => input)
+  .middleware([consoleAccess])
+  .validator((input: DeleteBundleInput) => input)
   .handler(async ({ data }) => {
     try {
-      const { prepareConfig } = await import("./server/config.server");
       const { deleteBundle: deleteBundleWithStorage } =
         await import("./server/deleteBundle");
-      const { databaseClient, storagePlugin } = await prepareConfig();
+      const { core, storagePlugin } = await prepare();
 
       await deleteBundleWithStorage(data, {
-        databaseClient,
+        core,
         storagePlugin,
         waitForStorageCleanup: false,
       });
@@ -385,16 +361,16 @@ export const deleteBundle = createServerFn({ method: "POST" })
   });
 
 export const deleteBundles = createServerFn({ method: "POST" })
-  .inputValidator((input: DeleteBundlesInput) => input)
+  .middleware([consoleAccess])
+  .validator((input: DeleteBundlesInput) => input)
   .handler(async ({ data }) => {
     try {
-      const { prepareConfig } = await import("./server/config.server");
       const { deleteBundles: deleteBundlesWithStorage } =
         await import("./server/deleteBundle");
-      const { databaseClient, storagePlugin } = await prepareConfig();
+      const { core, storagePlugin } = await prepare();
 
       const result = await deleteBundlesWithStorage(data, {
-        databaseClient,
+        core,
         storagePlugin,
         waitForStorageCleanup: false,
       });

package/src/lib/api.ts

@@ -1,6 +1,5 @@
 import type {
-  ChannelDeleteInput,
-  ChannelInsertInput,
+  ReleaseFilter,
   ReleasePolicyPatch,
 } from "@hot-updater/plugin-core";
 import {
@@ -34,9 +33,10 @@ import {
 
 type BundleFilters = {
   platform?: "ios" | "android";
-  page?: number;
-  limit?: string;
+  limit?: number;
+  /** Bundles older than this id: the next page. */
   after?: string;
+  /** Bundles newer than this id: the previous page. */
   before?: string;
 };
 
@@ -71,15 +71,13 @@ export const queryKeys = {
 };
 
 export type ReleaseFilters = {
-  afterReleaseId?: string;
+  /** One of the filter sets the release indexes serve; none lists every release. */
+  filter?: ReleaseFilter;
+  /** Releases older than this id: the next page. */
   beforeReleaseId?: string;
-  bundleId?: string;
-  channelId?: string;
-  enabled?: boolean;
-  platform?: "ios" | "android";
+  /** Releases newer than this id: the previous page. */
+  afterReleaseId?: string;
   limit?: number;
-  page?: number;
-  targetAppVersion?: string;
 };
 
 function removeBundleFromQueryData(
@@ -213,7 +211,7 @@ export function useCreateChannelMutation() {
   const queryClient = useQueryClient();
 
   return useMutation({
-    mutationFn: (input: ChannelInsertInput) =>
+    mutationFn: (input: { name: string }) =>
       createChannelApi({ data: input }).then((response) => response.data),
     onSuccess: async () => {
       await queryClient.invalidateQueries({ queryKey: queryKeys.channels });
@@ -225,7 +223,7 @@ export function useDeleteChannelMutation() {
   const queryClient = useQueryClient();
 
   return useMutation({
-    mutationFn: (input: ChannelDeleteInput) =>
+    mutationFn: (input: { id: string }) =>
       deleteChannelApi({ data: input }).then((response) => response.data),
     onSettled: async () => {
       await queryClient.invalidateQueries({ queryKey: queryKeys.channels });

package/src/lib/bundle-activity.ts

@@ -0,0 +1,31 @@
+import { useQuery } from "@tanstack/react-query";
+
+import type { RecoveryInput } from "./insights-recovery";
+import { getBundleActivityRpc } from "./insights-recovery-rpc";
+
+export type BundleActivityInput = Pick<
+  RecoveryInput,
+  "platform" | "channel"
+> & { readonly releaseId: string };
+
+export type BundleActivityReport = {
+  readonly downloads: number;
+  /** Each installation once for each UTC day it launched the release. */
+  readonly activeDays: number;
+  readonly failedLaunches: number;
+  readonly measuredAtMs: number;
+  readonly coverage: import("@hot-updater/server/plugins/insights").InsightsCoverage;
+};
+
+/** Release activity for bundle rows; mounted only where the console reads it. */
+export function useBundleActivityQuery(inputs: readonly BundleActivityInput[]) {
+  const sorted = [...inputs].sort((a, b) =>
+    a.releaseId.localeCompare(b.releaseId),
+  );
+  return useQuery({
+    queryKey: ["bundle-activity", sorted],
+    queryFn: () => getBundleActivityRpc({ data: sorted }),
+    enabled: sorted.length > 0,
+    staleTime: 30_000,
+  });
+}