@hot-updater/console 1.0.0-rc.8 → 1.0.0

package/src/lib/api-rpc.ts

@@ -1,30 +1,18 @@
 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;
-  after?: string;
-  before?: string;
-};
-
 type GetBundleInput = {
   bundleId: string;
 };
@@ -37,24 +25,14 @@ type GetBundleChildCountsInput = {
   bundleIds: string[];
 };
 
-type DeleteBundleInput = {
-  bundleId: string;
-};
-
-type DeleteBundlesInput = {
-  bundleIds: string[];
-};
-
 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 +46,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)
-  .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,
-    );
+  .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 { 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,260 +126,119 @@ 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);
-  });
-
-// 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;
-  }
-});
-
-// 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;
-  }
-});
-
-// POST /api/channels
-export const createChannel = createServerFn({ method: "POST" })
-  .inputValidator((input: ChannelInsertInput) => input)
-  .handler(async ({ data }) => {
+  .middleware([consoleAccess])
+  .validator((input: { scopeKey: string }) => input)
+  .handler(async ({ data }) =>
+    (await prepare()).core.getReleaseCatalogRow(data.scopeKey),
+  );
+
+export const getConfig = createServerFn()
+  .middleware([consoleAccess])
+  .handler(async () => {
     try {
-      const { prepareConfig } = await import("./server/config.server");
-      const { databaseClient } = await prepareConfig();
-      return { data: await databaseClient.insertChannel(data) };
+      const { config } = await prepare();
+      return { console: { gitUrl: config.gitUrl } };
     } catch (error) {
-      console.error("Error during channel creation:", error);
+      console.error("Error during config retrieval:", error);
       throw error;
     }
   });
 
-// DELETE /api/channels/:id
-export const deleteChannel = createServerFn({ method: "POST" })
-  .inputValidator((input: ChannelDeleteInput) => input)
-  .handler(async ({ data }) => {
+export const getChannels = createServerFn()
+  .middleware([consoleAccess])
+  .handler(async (): Promise<ChannelRow[]> => {
     try {
-      const { prepareConfig } = await import("./server/config.server");
-      const { databaseClient } = await prepareConfig();
-      return { data: await databaseClient.deleteChannel(data) };
+      return await (await prepare()).core.listChannels();
     } catch (error) {
-      console.error("Error during channel deletion:", error);
+      console.error("Error during channel retrieval:", error);
       throw error;
     }
   });
 
-// 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;
-  }
-});
-
-// GET /api/bundles
-export const getBundles = createServerFn({ method: "GET" })
-  .inputValidator((input: GetBundlesInput | undefined) => input)
+export const createChannel = createServerFn({ method: "POST" })
+  .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 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,
-      };
-      if (
-        (query.after !== undefined && query.before !== undefined) ||
-        (query.page !== undefined &&
-          (query.after !== undefined || query.before !== undefined))
-      ) {
-        throw new DatabasePluginInputError("invalid-pagination");
+      const { core } = await prepare();
+      const existing = await core.findChannelByName(data.name);
+      if (existing !== null) {
+        return { data: { row: existing, inserted: false } };
       }
-      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,
+      return {
+        data: { row: await core.ensureChannel(data.name), inserted: true },
       };
-      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;
-    }
-  });
-
-// GET /api/bundles/:bundleId
-export const getBundle = createServerFn({ method: "GET" })
-  .inputValidator((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;
     } catch (error) {
-      console.error("Error during bundle retrieval:", error);
+      console.error("Error during channel creation:", error);
       throw error;
     }
   });
 
-export const getBundleChildren = createServerFn({ method: "GET" })
-  .inputValidator((input: GetBundleChildrenInput) => input)
-  .handler(async ({ data }) => {
+export const deleteChannel = createServerFn({ method: "POST" })
+  .middleware([consoleAccess])
+  .validator((input: { id: string }) => input)
+  .handler(async ({ data }): Promise<{ data: ChannelDeleteResult }> => {
     try {
-      const { prepareConfig } = await import("./server/config.server");
-      const { getBundleChildren: getBundleChildrenWithConfig } =
-        await import("./server/getBundleChildren");
-      const { databaseClient } = await prepareConfig();
-
-      return await getBundleChildrenWithConfig(data, {
-        databaseClient,
-      });
+      return { data: await (await prepare()).core.deleteChannel(data.id) };
     } catch (error) {
-      console.error("Error during bundle children retrieval:", error);
+      console.error("Error during channel deletion:", error);
       throw error;
     }
   });
 
-export const getBundleChildCounts = createServerFn({ method: "GET" })
-  .inputValidator((input: GetBundleChildCountsInput) => input)
+export const getBundle = createServerFn({ method: "GET" })
+  .middleware([consoleAccess])
+  .validator((input: GetBundleInput) => 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,
-      });
+      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 child count retrieval:", error);
+      console.error("Error during bundle retrieval:", error);
       throw error;
     }
   });
 
-// POST /api/bundles
-export const createBundle = createServerFn({ method: "POST" })
-  .inputValidator((input: Bundle) => input)
+export const getBundleChildren = createServerFn({ method: "GET" })
+  .middleware([consoleAccess])
+  .validator((input: GetBundleChildrenInput) => 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 }, { getBundleChildren: readBundleChildren }] =
+        await Promise.all([prepare(), import("./server/getBundleChildren")]);
+      return await readBundleChildren(core, data.baseBundleId);
     } catch (error) {
-      console.error("Error during bundle creation:", error);
+      console.error("Error during bundle children retrieval:", error);
       throw error;
     }
   });
 
-// DELETE /api/bundles/:bundleId
-export const deleteBundle = createServerFn({ method: "POST" })
-  .inputValidator((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();
-
-      await deleteBundleWithStorage(data, {
-        databaseClient,
-        storagePlugin,
-        waitForStorageCleanup: false,
-      });
-
-      return { success: true };
-    } catch (error) {
-      console.error("Error during bundle deletion:", error);
-      throw error;
+export const getBundleChildCounts = createServerFn({ method: "GET" })
+  .middleware([consoleAccess])
+  .validator((input: GetBundleChildCountsInput) => {
+    if (!Array.isArray(input?.bundleIds) || input.bundleIds.length > 100) {
+      throw new Error("Choose up to 100 bundles.");
     }
-  });
-
-export const deleteBundles = createServerFn({ method: "POST" })
-  .inputValidator((input: DeleteBundlesInput) => input)
+    return 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 result = await deleteBundlesWithStorage(data, {
-        databaseClient,
-        storagePlugin,
-        waitForStorageCleanup: false,
-      });
-
-      return { success: true, ...result };
+      const [{ core }, { getBundleChildCounts: readBundleChildCounts }] =
+        await Promise.all([prepare(), import("./server/getBundleChildren")]);
+      return await readBundleChildCounts(core, data.bundleIds);
     } catch (error) {
-      console.error("Error during bundle deletion:", error);
+      console.error("Error during bundle child count retrieval:", error);
       throw error;
     }
   });