storybooker 0.19.4 → 0.22.0-canary.0

package/src/models/builds-model.ts

@@ -0,0 +1,373 @@
+// oxlint-disable switch-case-braces
+
+import { HTTPException } from "hono/http-exception";
+import type { StoryBookerPermissionAction } from "../adapters/_internal/auth.ts";
+import { handleProcessZip } from "../handlers/handle-process-zip.ts";
+import { urlBuilder } from "../urls.ts";
+import {
+  generateDatabaseCollectionId,
+  generateStorageContainerId,
+} from "../utils/adapter-utils.ts";
+import { checkAuthorisation } from "../utils/auth.ts";
+import { mimes } from "../utils/mime-utils.ts";
+import { getStore } from "../utils/store.ts";
+import {
+  BuildSchema,
+  type BuildCreateType,
+  type BuildStoryType,
+  type BuildType,
+  type BuildUpdateType,
+  type BuildUploadVariant,
+} from "./builds-schema.ts";
+import { ProjectsModel } from "./projects-model.ts";
+import { TagsModel } from "./tags-model.ts";
+import type { TagVariant } from "./tags-schema.ts";
+import { Model, type BaseModel, type ListOptions } from "./~model.ts";
+
+export class BuildsModel extends Model<BuildType> {
+  constructor(projectId: string) {
+    super(projectId, generateDatabaseCollectionId(projectId, "Builds"));
+  }
+
+  async list(options: ListOptions<BuildType> = {}): Promise<BuildType[]> {
+    if (options) {
+      this.log("List builds with options (%o)...", { ...options });
+    } else {
+      this.log("List builds...");
+    }
+
+    const items = await this.database.listDocuments(
+      this.collectionId,
+      { sort: "latest", ...options },
+      this.dbOptions,
+    );
+
+    return BuildSchema.array().parse(items);
+  }
+
+  async create(data: BuildCreateType): Promise<BuildType> {
+    const { tags: parsedTags, id, ...rest } = data;
+    this.log("Create build '%s'...", id);
+
+    try {
+      if (await this.has(id)) {
+        throw new HTTPException(409, {
+          message: `Build '${id}' already exists.`,
+        });
+      }
+
+      const tags = Array.isArray(parsedTags) ? parsedTags : parsedTags.split(",");
+      const tagIds = await Promise.all(
+        tags.filter(Boolean).map(async (tagId) => {
+          return await this.#updateOrCreateTag(tagId, id);
+        }),
+      );
+
+      const now = new Date().toISOString();
+      // oxlint-disable-next-line sort-keys
+      const build: BuildType = {
+        ...rest,
+        createdAt: now,
+        coverage: "none",
+        screenshots: "none",
+        storybook: "none",
+        testReport: "none",
+        id,
+        message: rest.message ?? "",
+        tagIds: tagIds.filter(Boolean).join(","),
+        updatedAt: now,
+      };
+      await this.database.createDocument(this.collectionId, build, this.dbOptions);
+
+      try {
+        const projectsModel = new ProjectsModel();
+        const project = await projectsModel.get(this.projectId);
+        if (tags.includes(project.gitHubDefaultBranch)) {
+          await projectsModel.update(this.projectId, { latestBuildId: id });
+        }
+      } catch (error) {
+        this.error("Error updating project with latest build ID:", error);
+      }
+
+      return build;
+    } catch (error) {
+      throw new HTTPException(500, {
+        cause: error,
+        message: `Failed to create build '${id}'.`,
+      });
+    }
+  }
+
+  async get(id: string): Promise<BuildType> {
+    this.log("Get build '%s'...", id);
+
+    const item = await this.database.getDocument(this.collectionId, id, this.dbOptions);
+
+    return BuildSchema.parse(item);
+  }
+
+  async has(id: string): Promise<boolean> {
+    this.log("Check build '%s'...", id);
+
+    try {
+      return await this.database.hasDocument(this.collectionId, id, this.dbOptions);
+    } catch {
+      return false;
+    }
+  }
+
+  async update(id: string, data: BuildUpdateType): Promise<void> {
+    this.log("Update build '%s''...", id);
+
+    await this.database.updateDocument(
+      this.collectionId,
+      id,
+      { ...data, updatedAt: new Date().toISOString() },
+      this.dbOptions,
+    );
+  }
+
+  async delete(buildId: string, updateTag = true): Promise<void> {
+    this.log("Delete build '%s'...", buildId);
+
+    const build = await this.get(buildId);
+
+    this.debug("Delete document '%s'", buildId);
+    await this.database.deleteDocument(this.collectionId, buildId, this.dbOptions);
+
+    try {
+      this.debug("Delete files '%s'", buildId);
+      await this.storage.deleteFiles(
+        generateStorageContainerId(this.projectId),
+        buildId,
+        this.storageOptions,
+      );
+    } catch (error) {
+      this.error("Cannot delete container:", error);
+    }
+
+    if (updateTag) {
+      this.debug("Update tags for build '%s'", buildId);
+      const tagIds = build.tagIds?.split(",") ?? [];
+      const tagsModel = new TagsModel(this.projectId);
+      await Promise.allSettled(
+        tagIds.map(async (tagId) => {
+          const tag = await tagsModel.get(tagId);
+          if (tag.latestBuildId === buildId) {
+            await tagsModel.update(tagId, {
+              buildsCount: Math.max(tag.buildsCount - 1, 0),
+              latestBuildId: "",
+            });
+          }
+        }),
+      );
+    }
+
+    try {
+      const projectsModel = new ProjectsModel();
+      const project = await projectsModel.get(this.projectId);
+      if (project.latestBuildId === buildId) {
+        this.debug("Update project for build '%s'", buildId);
+        await projectsModel.update(this.projectId, {
+          latestBuildId: "",
+        });
+      }
+    } catch (error) {
+      this.error("Cannot unset build ID from project:", error);
+    }
+  }
+
+  async upload(buildId: string, variant: BuildUploadVariant, zipFile?: File): Promise<void> {
+    const { config, request } = getStore();
+    this.log("Upload build '%s' (%s)...", buildId, variant);
+    const variantCopy = variant; // for switch fallthrough/default
+
+    switch (variant) {
+      case "coverage":
+      case "testReport":
+      case "screenshots":
+      case "storybook": {
+        const size = await this.#uploadZipFile(buildId, variant, zipFile);
+        await this.update(buildId, { [variant]: "uploaded" });
+
+        const {
+          maxInlineUploadProcessingSizeInBytes = 5 * 1024 * 1024,
+          queueLargeZipFileProcessing = false,
+        } = config ?? {};
+
+        // Automatically process zip if feature is enabled and size is below limit
+        if (size !== undefined && size <= maxInlineUploadProcessingSizeInBytes) {
+          await handleProcessZip(this.projectId, buildId, variant).catch((error: unknown) => {
+            this.error("Error processing zip file:", error);
+          });
+          return;
+        }
+
+        // Otherwise queue processing task if enabled
+        if (queueLargeZipFileProcessing) {
+          this.log("Queue processing for build '%s' (%s)...", buildId, variant);
+          const url = urlBuilder.taskProcessZip(this.projectId, buildId, variant);
+          // Do not await fetch to avoid blocking
+          fetch(url, { headers: request.headers, method: "POST" }).catch((error: unknown) => {
+            this.error("Error queuing zip file processing:", error);
+          });
+        }
+
+        return;
+      }
+
+      default:
+        throw new Error(`Unsupported upload variant: ${variantCopy}`);
+    }
+  }
+
+  id: BaseModel<BuildType>["id"] = (id: string) => {
+    return {
+      checkAuth: (action) =>
+        checkAuthorisation({
+          action,
+          projectId: this.projectId,
+          resource: "build",
+        }),
+      delete: this.delete.bind(this, id),
+      get: this.get.bind(this, id),
+      has: this.has.bind(this, id),
+      id,
+      update: this.update.bind(this, id),
+    };
+  };
+
+  checkAuth(action: StoryBookerPermissionAction): boolean {
+    return checkAuthorisation({
+      action,
+      projectId: this.projectId,
+      resource: "build",
+    });
+  }
+
+  async getStories(idOrBuild: string | BuildType): Promise<BuildStoryType[] | null> {
+    const { storybook, id } = typeof idOrBuild === "string" ? await this.get(idOrBuild) : idOrBuild;
+
+    if (storybook !== "ready") {
+      return null;
+    }
+
+    const { logger } = getStore();
+
+    try {
+      this.log("List stories '%s'...", id);
+
+      const buildIndexJsonPath = `${id}/storybook/index.json`;
+      const { content } = await this.storage.downloadFile(
+        generateStorageContainerId(this.projectId),
+        buildIndexJsonPath,
+        { logger },
+      );
+      const data: unknown =
+        typeof content === "string" ? JSON.parse(content) : await new Response(content).json();
+
+      if (!data || typeof data !== "object" || !("entries" in data) || !data.entries) {
+        return [];
+      }
+
+      return Object.values(data.entries) as BuildStoryType[];
+    } catch (error) {
+      this.error("Error getting stories:", error);
+      return null;
+    }
+  }
+
+  // helpers
+  async listByTag(tagId: string): Promise<BuildType[]> {
+    const builds = await this.list({
+      filter: (item) => (item.tagIds ? item.tagIds.split(",").includes(tagId) : false),
+    });
+
+    return builds;
+  }
+
+  async deleteByTag(tagId: string, force: boolean): Promise<void> {
+    const builds = await this.listByTag(tagId);
+    this.log(
+      "Delete builds by tag: '%s' (%d, force: %s)...",
+      tagId,
+      builds.length,
+      force.valueOf(),
+    );
+
+    await Promise.allSettled(
+      builds.map(async (build): Promise<void> => {
+        const buildTagIds = build.tagIds?.split(",") ?? [];
+        if (!force && buildTagIds.length > 1) {
+          const newIds = buildTagIds.filter((id) => id !== tagId);
+          await this.update(build.id, { tagIds: newIds.join(",") });
+        } else {
+          await this.delete(build.id, false);
+        }
+      }),
+    );
+  }
+
+  async #updateOrCreateTag(tagId: string, buildId: string): Promise<string> {
+    const tagsModel = new TagsModel(this.projectId);
+    // Either "my-tag" or "my-tag;branch" or "my-tag;branch;My tag"
+    const [id = tagId, tagType, tagValue] = tagId.split(";").map((part) => part.trim());
+
+    try {
+      const existingTag = await tagsModel.get(id);
+      await tagsModel.update(id, {
+        buildsCount: existingTag.buildsCount + 1,
+        latestBuildId: buildId,
+      });
+      return id;
+    } catch {
+      try {
+        const type = (tagType as TagVariant) ?? TagsModel.guessType(id);
+        const value = tagValue ?? id;
+        this.log("A new tag '%s' (%s) is being created.", value, type);
+        const tag = await tagsModel.create({ latestBuildId: buildId, type, value }, true);
+
+        return tag.id;
+      } catch (error) {
+        this.error("Error creating tag:", error);
+        return id;
+      }
+    }
+  }
+
+  async #uploadZipFile(
+    buildId: string,
+    variant: BuildUploadVariant,
+    zipFile?: File,
+  ): Promise<number | undefined> {
+    const { request } = getStore();
+    this.debug("(%s-%s) Uploading zip file", buildId, variant);
+
+    const content: string | Blob | ReadableStream | null = zipFile
+      ? zipFile.stream()
+      : request.body;
+
+    if (!content) {
+      throw new Error(`No content found for zip file.`);
+    }
+
+    await this.storage.uploadFiles(
+      generateStorageContainerId(this.projectId),
+      [
+        {
+          content,
+          mimeType: mimes.zip,
+          path: `${buildId}/${variant}.zip`,
+        },
+      ],
+      this.storageOptions,
+    );
+
+    if (!zipFile) {
+      const length = request.headers.get("Content-Length");
+      return length ? Number(length) : undefined;
+    }
+
+    return zipFile?.size;
+  }
+}

package/src/models/builds-schema.ts

@@ -0,0 +1,84 @@
+// oxlint-disable sort-keys
+
+import { z } from "@hono/zod-openapi";
+import { buildUploadVariants } from "../utils/constants.ts";
+import { BuildIdSchema, TagIdSchema } from "./~shared-schema.ts";
+
+const buildContentAvailabilityOptions = ["none", "uploaded", "processing", "ready"] as const;
+
+export type BuildType = z.infer<typeof BuildSchema>;
+/** @private */
+export const BuildSchema = z
+  .object({
+    authorEmail: z
+      .string()
+      .refine((val) => val.includes("@"), "Invalid email format")
+      .meta({ description: "Email of the author" }),
+    authorName: z.string(),
+    createdAt: z.iso.datetime().default(new Date().toISOString()),
+    id: BuildIdSchema,
+    tagIds: z.string().optional(),
+    message: z.optional(z.string()),
+    updatedAt: z.iso.datetime().default(new Date().toISOString()),
+    coverage: z.enum(buildContentAvailabilityOptions),
+    screenshots: z.enum(buildContentAvailabilityOptions),
+    storybook: z.enum(buildContentAvailabilityOptions),
+    testReport: z.enum(buildContentAvailabilityOptions),
+  })
+  .meta({ id: "Build", title: "StoryBooker Build" });
+
+export type BuildCreateType = z.infer<typeof BuildCreateSchema>;
+/** @private */
+export const BuildCreateSchema = BuildSchema.omit({
+  createdAt: true,
+  coverage: true,
+  screenshots: true,
+  storybook: true,
+  testReport: true,
+  tagIds: true,
+  updatedAt: true,
+}).extend({
+  tags: z.union([TagIdSchema.array(), TagIdSchema]).meta({
+    description: "Tag IDs associated with the build. Should be created beforehand.",
+  }),
+});
+
+export type BuildUpdateType = z.infer<typeof BuildUpdateSchema>;
+export const BuildUpdateSchema = BuildSchema.omit({
+  createdAt: true,
+  id: true,
+  updatedAt: true,
+}).partial();
+
+export type BuildUploadVariant = (typeof buildUploadVariants)[number];
+export const BuildUploadQueryParamsSchema = z.object({
+  variant: z.enum(buildUploadVariants).default("storybook"),
+});
+export const BuildUploadFormBodySchema = z.object({
+  file: z.file().openapi({ type: "object" }),
+  variant: z.enum(buildUploadVariants).default("storybook"),
+});
+
+export type BuildsListResultType = z.infer<typeof BuildsListResultSchema>;
+export const BuildsListResultSchema = z.object({
+  builds: BuildSchema.array(),
+});
+export type BuildsGetResultType = z.infer<typeof BuildsGetResultSchema>;
+export const BuildsGetResultSchema = z.object({
+  build: BuildSchema,
+  url: z.url(),
+});
+
+export type BuildStoryType = z.infer<typeof BuildStorySchema>;
+export const BuildStorySchema = z.object({
+  id: z.string(),
+  title: z.string(),
+  name: z.string(),
+  importPath: z.string(),
+  tags: z.array(z.string()),
+  type: z.enum(["docs", "story"]),
+  componentPath: z.string().optional(),
+  storiesImports: z.array(z.string()).optional(),
+});
+
+export { BuildIdSchema, buildUploadVariants };

package/src/models/projects-model.ts

@@ -0,0 +1,177 @@
+import { HTTPException } from "hono/http-exception";
+import type { StoryBookerPermissionAction } from "../adapters/_internal/auth.ts";
+import {
+  generateDatabaseCollectionId,
+  generateStorageContainerId,
+} from "../utils/adapter-utils.ts";
+import { checkAuthorisation } from "../utils/auth.ts";
+import {
+  ProjectSchema,
+  type ProjectCreateType,
+  type ProjectType,
+  type ProjectUpdateType,
+} from "./projects-schema.ts";
+import { TagsModel } from "./tags-model.ts";
+import { Model, type BaseModel, type ListOptions } from "./~model.ts";
+
+export class ProjectsModel extends Model<ProjectType> {
+  constructor() {
+    super(null, generateDatabaseCollectionId("Projects", ""));
+  }
+
+  async list(options: ListOptions<ProjectType> = {}): Promise<ProjectType[]> {
+    this.log("List projects...");
+
+    try {
+      const items = await this.database.listDocuments(this.collectionId, options, this.dbOptions);
+
+      return items;
+    } catch (error) {
+      this.error("Error listing projects:", error);
+      return [];
+    }
+  }
+
+  async create(data: ProjectCreateType): Promise<ProjectType> {
+    this.log("Creating project...");
+
+    const projectId = data.id;
+
+    try {
+      if (await this.has(projectId)) {
+        throw new HTTPException(409, {
+          message: `Project '${projectId}' already exists.`,
+        });
+      }
+
+      await this.storage.createContainer(
+        generateStorageContainerId(projectId),
+        this.storageOptions,
+      );
+
+      this.debug("Creating project collection");
+      await this.database
+        .createCollection(this.collectionId, this.dbOptions)
+        .catch((error: unknown) => {
+          // ignore error if collection already exists since there can only be one projects collection
+          this.error("Error creating projects collection:", error);
+        });
+
+      await this.database.createCollection(
+        generateDatabaseCollectionId(projectId, "Builds"),
+        this.dbOptions,
+      );
+
+      await this.database.createCollection(
+        generateDatabaseCollectionId(projectId, "Tags"),
+        this.dbOptions,
+      );
+
+      this.debug("Creating default branch (%s) tag", data.gitHubDefaultBranch);
+      await new TagsModel(projectId)
+        .create({
+          type: "branch",
+          value: data.gitHubDefaultBranch,
+        })
+        .catch((error: unknown) => {
+          // log error but continue since project creation should not fail because of tag creation
+          this.error("Error creating default branch tag:", error);
+        });
+
+      this.debug("Creating project entry '%s' in collection", projectId);
+      const now = new Date().toISOString();
+      const project: ProjectType = {
+        ...data,
+        createdAt: now,
+        updatedAt: now,
+      };
+      await this.database.createDocument(this.collectionId, project, this.dbOptions);
+
+      return project;
+    } catch (error) {
+      throw new HTTPException(500, {
+        cause: error,
+        message: `Failed to create project '${projectId}'.`,
+      });
+    }
+  }
+
+  async get(id: string): Promise<ProjectType> {
+    this.log("Get project '%s'...", id);
+
+    const item = await this.database.getDocument(this.collectionId, id, this.dbOptions);
+
+    return ProjectSchema.parse(item);
+  }
+
+  async has(id: string): Promise<boolean> {
+    this.log("Check project '%s'...", id);
+
+    try {
+      return await this.database.hasDocument(this.collectionId, id, this.dbOptions);
+    } catch {
+      return false;
+    }
+  }
+
+  async update(id: string, data: ProjectUpdateType): Promise<void> {
+    this.log("Update project '%s'...", id);
+
+    await this.database.updateDocument(
+      this.collectionId,
+      id,
+      { ...data, updatedAt: new Date().toISOString() },
+      this.dbOptions,
+    );
+
+    if (data.gitHubDefaultBranch) {
+      try {
+        this.debug("Create default-branch tag '%s'...", data.gitHubDefaultBranch);
+        await new TagsModel(id).create({
+          type: "branch",
+          value: data.gitHubDefaultBranch,
+        });
+      } catch (error) {
+        this.error("Error creating default branch tag:", error);
+      }
+    }
+  }
+
+  async delete(id: string): Promise<void> {
+    this.log("Delete project '%s'...", id);
+
+    this.debug("Delete project entry '%s' in collection", id);
+    await this.database.deleteDocument(this.collectionId, id, this.dbOptions);
+
+    this.debug("Delete project-builds collection");
+    await this.database.deleteCollection(
+      generateDatabaseCollectionId(id, "Builds"),
+      this.dbOptions,
+    );
+
+    this.debug("Delete project-tags collection");
+    await this.database.deleteCollection(generateDatabaseCollectionId(id, "Tags"), this.dbOptions);
+
+    this.debug("Delete project container");
+    await this.storage.deleteContainer(generateStorageContainerId(id), this.storageOptions);
+  }
+
+  checkAuth(action: StoryBookerPermissionAction, id?: string): boolean {
+    return checkAuthorisation({
+      action,
+      projectId: id ?? (this.projectId || undefined),
+      resource: "project",
+    });
+  }
+
+  id: BaseModel<ProjectType>["id"] = (id: string) => {
+    return {
+      checkAuth: (action) => checkAuthorisation({ action, projectId: id, resource: "project" }),
+      delete: this.delete.bind(this, id),
+      get: this.get.bind(this, id),
+      has: this.has.bind(this, id),
+      id,
+      update: this.update.bind(this, id),
+    };
+  };
+}

package/src/models/projects-schema.ts

@@ -0,0 +1,69 @@
+import { z } from "@hono/zod-openapi";
+import { DEFAULT_GITHUB_BRANCH, DEFAULT_PURGE_AFTER_DAYS } from "../utils/constants.ts";
+import { BuildIdSchema, ProjectIdSchema } from "./~shared-schema.ts";
+
+export { ProjectIdSchema };
+
+export type ProjectType = z.infer<typeof ProjectSchema>;
+
+export const ProjectSchema = z
+  .object({
+    createdAt: z.iso.datetime().default(new Date().toISOString()),
+
+    gitHubDefaultBranch: z
+      .string()
+      .default(DEFAULT_GITHUB_BRANCH)
+      .meta({ description: "Default branch to use for GitHub repository" }),
+    gitHubPath: z.string().optional().meta({
+      description: "Path to the storybook project with respect to repository root.",
+    }),
+    gitHubRepository: z.string().check(
+      z.minLength(1, "Query-param 'gitHubRepo' is required."),
+      z.refine(
+        (val) => val.split("/").length === 2,
+        "Query-param 'gitHubRepo' should be in the format 'owner/repo'.",
+      ),
+    ),
+
+    id: ProjectIdSchema,
+
+    jiraDomain: z.union([z.url().optional(), z.literal("")]),
+
+    latestBuildId: z.union([BuildIdSchema.optional(), z.literal("")]),
+
+    name: z.string().meta({ description: "Name of the project." }),
+
+    purgeBuildsAfterDays: z.coerce.number().min(1).default(DEFAULT_PURGE_AFTER_DAYS).meta({
+      description: "Days after which the builds in the project should be purged.",
+    }),
+
+    updatedAt: z.iso.datetime().default(new Date().toISOString()),
+  })
+  .meta({ id: "Project", title: "StoryBooker project" });
+
+export type ProjectCreateType = z.infer<typeof ProjectCreateSchema>;
+export const ProjectCreateSchema = ProjectSchema.omit({
+  createdAt: true,
+  latestBuildId: true,
+  updatedAt: true,
+});
+
+export type ProjectUpdateType = z.infer<typeof ProjectUpdateSchema>;
+export const ProjectUpdateSchema = ProjectSchema.omit({
+  createdAt: true,
+  gitHubDefaultBranch: true,
+  id: true,
+  updatedAt: true,
+})
+  .extend({ gitHubDefaultBranch: z.string() })
+  .partial();
+
+export type ProjectsListResultType = z.infer<typeof ProjectsListResultSchema>;
+export const ProjectsListResultSchema = z.object({
+  projects: ProjectSchema.array(),
+});
+
+export type ProjectGetResultType = z.infer<typeof ProjectGetResultSchema>;
+export const ProjectGetResultSchema = z.object({
+  project: ProjectSchema,
+});