docs(changeset): Add purge functionality

Author: GuptaSiddhant

.changeset/strong-lions-beg.md

@@ -0,0 +1,6 @@
+---
+"@storybooker/azure-functions": minor
+"@storybooker/core": minor
+---
+
+Add purge functionality

packages/azure-functions/src/index.ts

@@ -1,5 +1,5 @@
 import { app } from "@azure/functions";
-import { createRequestHandler } from "@storybooker/core";
+import { createPurgeHandler, createRequestHandler } from "@storybooker/core";
 import { SERVICE_NAME } from "@storybooker/core/constants";
 import type {
   RequestHandlerOptions,
@@ -12,7 +12,7 @@ import {
   transformWebResponseToHttpResponse,
 } from "./utils";
 
-// const DEFAULT_PURGE_SCHEDULE_CRON = "0 0 0 * * *";
+const DEFAULT_PURGE_SCHEDULE_CRON = "0 0 0 * * *";
 
 export type * from "@storybooker/core/types";
 
@@ -48,7 +48,7 @@ export interface RegisterStorybookerRouterOptions<User extends StoryBookerUser>
    *
    * @default "0 0 0 * * *" // Every midnight
    */
-  // purgeScheduleCron?: string | null;
+  purgeScheduleCron?: string | null;
 }
 
 export function registerStoryBookerRouter<User extends StoryBookerUser>(
@@ -77,11 +77,21 @@ export function registerStoryBookerRouter<User extends StoryBookerUser>(
     route: urlJoin(route, "{**path}"),
   });
 
-  // if (options.purgeScheduleCron !== null) {
-  //   app.timer(`${SERVICE_NAME}-timer_purge`, {
-  //     handler: wrapTimerHandlerWithStore(routerOptions, timerPurgeHandler),
-  //     runOnStartup: false,
-  //     schedule: options.purgeScheduleCron || DEFAULT_PURGE_SCHEDULE_CRON,
-  //   });
-  // }
+  if (options.purgeScheduleCron !== null) {
+    const schedule = options.purgeScheduleCron || DEFAULT_PURGE_SCHEDULE_CRON;
+    const purgeHandler = createPurgeHandler({
+      database: options.database,
+      errorParser: options.errorParser ?? parseAzureRestError,
+      logger,
+      storage: options.storage,
+    });
+
+    logger.log("Registering Storybooker Timer-Purge (cron: %s)", schedule);
+    app.timer(`${SERVICE_NAME}-timer_purge`, {
+      // oxlint-disable-next-line require-await
+      handler: async (_timer, context) => purgeHandler({}, { logger: context }),
+      runOnStartup: false,
+      schedule,
+    });
+  }
 }

packages/core/README.md

@@ -43,3 +43,19 @@ const options: RequestHandlerOptions = {
 
 export default { fetch: createRequestHandler(options) };
 ```
+
+## Exports
+
+### `createRequestHandler`
+
+Callback to create a request-handler based on provided options.
+
+The request handler takes Standard Request and returns a Response asynchronously.
+
+### `createPurgeHandler`
+
+Callback to create a purge-handler based on provided options.
+
+Purging deletes all builds older than certain days based on Project's configuration.
+
+Note: The latest build on project's default branch is not deleted.

packages/core/src/builds/model.ts

@@ -165,7 +165,10 @@ export class BuildsModel extends Model<BuildType> {
         labelSlugs.map(async (labelSlug) => {
           const label = await labelsModel.get(labelSlug);
           if (label.latestBuildSHA === buildId) {
-            await labelsModel.update(labelSlug, { latestBuildSHA: undefined });
+            await labelsModel.update(labelSlug, {
+              buildsCount: Math.max(label.buildsCount - 1, 0),
+              latestBuildSHA: undefined,
+            });
           }
         }),
       );
@@ -265,18 +268,25 @@ export class BuildsModel extends Model<BuildType> {
       .map((part) => part.trim());
 
     try {
-      await labelsModel.update(slug, { latestBuildSHA: buildSHA });
+      const existingLabel = await labelsModel.get(labelSlug);
+      await labelsModel.update(slug, {
+        buildsCount: existingLabel.buildsCount + 1,
+        latestBuildSHA: buildSHA,
+      });
       return slug;
     } catch {
       try {
         const type = labelType || LabelsModel.guessType(slug);
         const value = labelValue || slug;
         this.log("A new label '%s' (%s) is being created.", value, type);
-        const label = await labelsModel.create({
-          latestBuildSHA: buildSHA,
-          type,
-          value,
-        });
+        const label = await labelsModel.create(
+          {
+            latestBuildSHA: buildSHA,
+            type,
+            value,
+          },
+          true,
+        );
 
         return label.id;
       } catch (error) {

packages/core/src/builds/routes.ts

@@ -235,7 +235,7 @@ export const deleteBuild = defineRoute(
       projectId,
       resource: "build",
     });
-    await new BuildsModel(projectId).delete(buildSHA);
+    await new BuildsModel(projectId).delete(buildSHA, true);
 
     if (checkIsHTMLRequest() || checkIsHXRequest()) {
       return responseRedirect(urlBuilder.allBuilds(projectId), 303);

packages/core/src/handlers/handle-purge.ts

@@ -0,0 +1,72 @@
+import { BuildsModel } from "#builds/model";
+import { DEFAULT_PURGE_AFTER_DAYS, ONE_DAY_IN_MS } from "#constants";
+import { LabelsModel } from "#labels/model";
+import { ProjectsModel } from "#projects/model";
+import type { ProjectType } from "#projects/schema";
+import { getStore } from "#store";
+import type { LoggerService } from "../types";
+
+export type HandlePurge = (
+  params: { projectId?: string },
+  options: { abortSignal?: AbortSignal; logger?: LoggerService },
+) => Promise<void>;
+
+export const handlePurge: HandlePurge = async ({ projectId }) => {
+  const projectModel = new ProjectsModel();
+  if (projectId) {
+    const project = await projectModel.get(projectId);
+    await purgeProject(project);
+  } else {
+    const projects = await projectModel.list();
+    const promises = projects.map((project) => purgeProject(project));
+    await Promise.allSettled(promises);
+  }
+};
+
+async function purgeProject(project: ProjectType): Promise<void> {
+  const { locale, logger } = getStore();
+  const {
+    id: projectId,
+    gitHubDefaultBranch,
+    latestBuildSHA,
+    purgeBuildsAfterDays = DEFAULT_PURGE_AFTER_DAYS,
+  } = project;
+  const expiryTime = new Date(
+    Date.now() - purgeBuildsAfterDays * ONE_DAY_IN_MS,
+  );
+  logger.log(
+    `[Project: ${projectId}] Purge builds which were last modified more than ${purgeBuildsAfterDays} days ago - since ${new Date(
+      expiryTime,
+    ).toLocaleString(locale)}`,
+  );
+
+  const buildsModel = new BuildsModel(projectId);
+  const expiredBuilds = await buildsModel.list({
+    filter: (item) =>
+      item.id !== latestBuildSHA && new Date(item.updatedAt) < expiryTime,
+  });
+  for (const build of expiredBuilds) {
+    // oxlint-disable-next-line no-await-in-loop
+    await buildsModel.delete(build.id, true);
+  }
+  logger.log(
+    `[Project: ${projectId}] Purged ${expiredBuilds.length} expired builds.`,
+  );
+
+  const labelsModel = new LabelsModel(projectId);
+  const emptyLabels = await labelsModel.list({
+    filter: (item) => {
+      if (item.type === "branch" && item.value === gitHubDefaultBranch) {
+        return false;
+      }
+      return item.buildsCount === 0;
+    },
+  });
+  for (const label of emptyLabels) {
+    // oxlint-disable-next-line no-await-in-loop
+    await labelsModel.delete(label.id);
+  }
+  logger.log(
+    `[Project: ${projectId}] Purged ${emptyLabels.length} empty labels...`,
+  );
+}

packages/core/src/index.ts

@@ -4,11 +4,13 @@ import { DEFAULT_LOCALE, HEADERS } from "#constants";
 import { localStore } from "#store";
 import { parseErrorMessage } from "#utils/error";
 import { createMiddlewaresPipelineRequestHandler } from "#utils/middleware-utils";
+import { handlePurge, type HandlePurge } from "./handlers/handle-purge";
 import { handleStaticFileRoute } from "./handlers/handle-static-file-route";
 import { router } from "./router";
 import { translations_enGB } from "./translations/en-gb";
 import type {
   AuthService,
+  PurgeHandlerOptions,
   RequestHandler,
   RequestHandlerOptions,
   StoryBookerUser,
@@ -32,7 +34,6 @@ export function createRequestHandler<User extends StoryBookerUser>(
   options: RequestHandlerOptions<User>,
 ): RequestHandler {
   const logger = options.logger || console;
-
   const initPromises = Promise.allSettled([
     options.auth?.init?.({}).catch(logger.error),
     options.database.init?.({}).catch(logger.error),
@@ -89,3 +90,42 @@ export function createRequestHandler<User extends StoryBookerUser>(
 
   return requestHandler;
 }
+
+/**
+ * Callback to create a purge-handler based on provided options.
+ * Purging deletes all builds older than certain days based on Project's configuration.
+ *
+ * Note: The latest build on project's default branch is not deleted.
+ */
+export function createPurgeHandler(options: PurgeHandlerOptions): HandlePurge {
+  const logger = options.logger || console;
+  const initPromises = Promise.allSettled([
+    options.database.init?.({}).catch(logger.error),
+    options.storage.init?.({}).catch(logger.error),
+  ]);
+
+  return async (...params: Parameters<HandlePurge>) => {
+    // Make sure initialisations are complete before first request is handled.
+    await initPromises;
+
+    try {
+      localStore.enterWith({
+        abortSignal: params[1].abortSignal,
+        database: options.database,
+        errorParser: options.errorParser,
+        locale: DEFAULT_LOCALE,
+        logger: params[1]?.logger ?? logger,
+        prefix: "/",
+        request: new Request(""),
+        storage: options.storage,
+        translation: translations_enGB,
+        url: "/",
+        user: null,
+      });
+
+      await handlePurge(...params);
+    } catch (error) {
+      logger.error(parseErrorMessage(error, options.errorParser).errorMessage);
+    }
+  };
+}

packages/core/src/labels/model.ts

@@ -30,14 +30,15 @@ export class LabelsModel extends Model<LabelType> {
     return LabelSchema.array().parse(items);
   }
 
-  async create(data: unknown): Promise<LabelType> {
+  async create(data: unknown, withBuild = false): Promise<LabelType> {
     const parsedData = LabelCreateSchema.parse(data);
     this.log("Create label '%s'...", parsedData.value);
 
     const slug = LabelsModel.createSlug(parsedData.value);
     const now = new Date().toISOString();
     const label: LabelType = {
       ...parsedData,
+      buildsCount: withBuild ? 1 : 0,
       createdAt: now,
       id: slug,
       slug,

packages/core/src/labels/schema.ts

@@ -7,6 +7,7 @@ export type LabelType = z.infer<typeof LabelSchema>;
 /** @private */
 export const LabelSchema = z
   .object({
+    buildsCount: z.number().default(0),
     createdAt: z.iso.datetime().default(new Date().toISOString()),
     id: LabelSlugSchema,
     latestBuildSHA: z.union([BuildSHASchema.optional(), z.literal("")]),
@@ -19,6 +20,7 @@ export const LabelSchema = z
 
 export type LabelCreateType = z.infer<typeof LabelCreateSchema>;
 export const LabelCreateSchema = LabelSchema.omit({
+  buildsCount: true,
   createdAt: true,
   id: true,
   slug: true,

packages/core/src/root/routes.ts

@@ -6,9 +6,10 @@ import { URLS } from "#urls";
 import { authenticateOrThrow } from "#utils/auth";
 import { checkIsJSONRequest } from "#utils/request";
 import { commonErrorResponses, responseHTML } from "#utils/response";
-import { urlJoin } from "#utils/url";
+import { urlJoin, urlSearchParamsToObject } from "#utils/url";
 import z from "zod";
 import { handleOpenAPIRoute } from "../handlers/handle-openapi-route";
+import { handlePurge } from "../handlers/handle-purge";
 import { handleServeStoryBook } from "../handlers/handle-serve-storybook";
 import { renderRootPage } from "./render";
 
@@ -125,3 +126,30 @@ export const openapi = defineRoute(
   },
   handleOpenAPIRoute,
 );
+
+const purgeSearchParams = z.object({ project: z.string().optional() }).loose();
+export const purge = defineRoute(
+  "post",
+  URLS.ui.purge,
+  {
+    requestParams: { query: purgeSearchParams },
+    responses: { 204: { description: "Purge complete" } },
+    summary: "Purge old data",
+  },
+  async ({ request }) => {
+    const { searchParams } = new URL(request.url);
+    const { project: projectId } = purgeSearchParams.parse(
+      urlSearchParamsToObject(searchParams),
+    );
+
+    await authenticateOrThrow({
+      action: "delete",
+      projectId,
+      resource: "project",
+    });
+
+    await handlePurge({ projectId }, {});
+
+    return new Response(null, { status: 204 });
+  },
+);