storybooker 0.19.4 → 0.22.0-canary.0

package/src/routers/tags-router.ts

@@ -0,0 +1,339 @@
+import { createRoute, OpenAPIHono } from "@hono/zod-openapi";
+import { HTTPException } from "hono/http-exception";
+import { z } from "zod";
+import { BuildsModel } from "../models/builds-model.ts";
+import { ProjectsModel } from "../models/projects-model.ts";
+import { ProjectIdSchema } from "../models/projects-schema.ts";
+import { TagsModel } from "../models/tags-model.ts";
+import {
+  TagCreateSchema,
+  TagIdSchema,
+  TagsGetResultSchema,
+  TagsListResultSchema,
+  TagTypes,
+  TagUpdateSchema,
+} from "../models/tags-schema.ts";
+import { urlBuilder } from "../urls.ts";
+import { authenticateOrThrow } from "../utils/auth.ts";
+import { mimes } from "../utils/mime-utils.ts";
+import {
+  openapiCommonErrorResponses,
+  openapiErrorResponseContent,
+  openapiResponseRedirect,
+  openapiResponsesHtml,
+} from "../utils/openapi-utils.ts";
+import { checkIsHTMLRequest } from "../utils/request.ts";
+import { getStore } from "../utils/store.ts";
+import { createUIResultResponse } from "../utils/ui-utils.ts";
+
+const tagsTag = "Tags";
+const projectIdPathParams = z.object({ projectId: ProjectIdSchema });
+const tagIdPathParams = z.object({
+  projectId: ProjectIdSchema,
+  tagId: TagIdSchema,
+});
+
+/**
+ * @private
+ */
+export const tagsRouter = new OpenAPIHono()
+  .openapi(
+    createRoute({
+      summary: "List tags",
+      method: "get",
+      path: "/projects/{projectId}/tags",
+      tags: [tagsTag],
+      request: {
+        params: projectIdPathParams,
+        query: z.object({ type: z.union([z.enum(TagTypes), z.literal("")]) }).partial(),
+      },
+      responses: {
+        200: {
+          description: "A list of tags in the project.",
+          content: {
+            [mimes.json]: { schema: TagsListResultSchema },
+            ...openapiResponsesHtml,
+          },
+        },
+        ...openapiCommonErrorResponses,
+      },
+    }),
+    async (context) => {
+      const { ui } = getStore();
+      const { projectId } = context.req.valid("param");
+
+      authenticateOrThrow({
+        action: "read",
+        projectId,
+        resource: "tag",
+      });
+
+      const { type } = context.req.valid("query");
+      const tags = await new TagsModel(projectId).list();
+      const filteredTags = type ? tags.filter((tag) => tag.type === type) : tags;
+
+      if (ui?.renderTagsListPage && checkIsHTMLRequest()) {
+        const project = await new ProjectsModel().get(projectId);
+
+        return createUIResultResponse(context, ui.renderTagsListPage, {
+          project,
+          tags: filteredTags,
+          defaultType: type,
+        });
+      }
+
+      return context.json({ tags: filteredTags });
+    },
+  )
+  .openapi(
+    createRoute({
+      summary: "Create tag - UI",
+      method: "get",
+      path: "/projects/{projectId}/tags/create",
+      tags: [tagsTag],
+      request: { params: projectIdPathParams },
+      responses: {
+        200: {
+          description: "UI to create tag",
+          content: openapiResponsesHtml,
+        },
+        ...openapiCommonErrorResponses,
+      },
+    }),
+    async (context) => {
+      const { ui } = getStore();
+      if (!ui?.renderTagCreatePage) {
+        throw new HTTPException(405, { message: "UI not available for this route." });
+      }
+
+      const { projectId } = context.req.valid("param");
+
+      authenticateOrThrow({
+        action: "create",
+        projectId,
+        resource: "tag",
+      });
+
+      const project = await new ProjectsModel().get(projectId);
+
+      return createUIResultResponse(context, ui.renderTagCreatePage, { project });
+    },
+  )
+  .openapi(
+    createRoute({
+      summary: "Create tag - action",
+      method: "post",
+      path: "/projects/{projectId}/tags/create",
+      tags: [tagsTag],
+      request: {
+        params: projectIdPathParams,
+        body: {
+          content: { [mimes.formEncoded]: { schema: TagCreateSchema } },
+          required: true,
+        },
+      },
+      responses: {
+        201: {
+          description: "Tag created successfully",
+          content: { [mimes.json]: { schema: TagsGetResultSchema } },
+        },
+        303: openapiResponseRedirect("Redirect to tag."),
+        409: {
+          content: openapiErrorResponseContent,
+          description: "Tag already exists.",
+        },
+        415: {
+          content: openapiErrorResponseContent,
+          description: "Unsupported Media Type",
+        },
+        ...openapiCommonErrorResponses,
+      },
+    }),
+    async (context) => {
+      const { projectId } = context.req.valid("param");
+
+      const projectModel = new ProjectsModel().id(projectId);
+      if (!(await projectModel.has())) {
+        throw new HTTPException(404, { message: `The project '${projectId}' does not exist.` });
+      }
+
+      authenticateOrThrow({
+        action: "create",
+        projectId,
+        resource: "tag",
+      });
+
+      const data = context.req.valid("form");
+      const tag = await new TagsModel(projectId).create(data);
+
+      if (checkIsHTMLRequest(true)) {
+        return context.redirect(urlBuilder.tagDetails(projectId, tag.id), 303);
+      }
+
+      return context.json({ tag }, 201);
+    },
+  )
+  .openapi(
+    createRoute({
+      summary: "Tag details",
+      method: "get",
+      path: "/projects/{projectId}/tags/{tagId}",
+      tags: [tagsTag],
+      request: { params: tagIdPathParams },
+      responses: {
+        200: {
+          description: "Details of the tag",
+          content: {
+            [mimes.json]: { schema: TagsGetResultSchema },
+            ...openapiResponsesHtml,
+          },
+        },
+        404: {
+          description: "Matching tag not found.",
+          content: openapiErrorResponseContent,
+        },
+        ...openapiCommonErrorResponses,
+      },
+    }),
+    async (context) => {
+      const { ui } = getStore();
+      const { projectId, tagId } = context.req.valid("param");
+
+      authenticateOrThrow({
+        action: "read",
+        projectId,
+        resource: "tag",
+      });
+
+      const tag = await new TagsModel(projectId).get(tagId);
+
+      if (ui?.renderTagDetailsPage && checkIsHTMLRequest()) {
+        const project = await new ProjectsModel().get(projectId);
+        const builds = await new BuildsModel(projectId).listByTag(tag.id);
+
+        return createUIResultResponse(context, ui.renderTagDetailsPage, { builds, project, tag });
+      }
+
+      return context.json({ tag });
+    },
+  )
+  .openapi(
+    createRoute({
+      summary: "Delete tag - action",
+      method: "post",
+      path: "/projects/{projectId}/tags/{tagId}/delete",
+      tags: [tagsTag],
+      request: { params: tagIdPathParams },
+      responses: {
+        204: { description: "Tag deleted successfully." },
+        303: openapiResponseRedirect("Redirect to tags list."),
+        404: {
+          description: "Matching tag not found.",
+          content: openapiErrorResponseContent,
+        },
+        ...openapiCommonErrorResponses,
+      },
+    }),
+    async (context) => {
+      const { projectId, tagId } = context.req.valid("param");
+      authenticateOrThrow({
+        action: "delete",
+        projectId,
+        resource: "tag",
+      });
+
+      await new TagsModel(projectId).delete(tagId);
+
+      if (checkIsHTMLRequest(true)) {
+        return context.redirect(urlBuilder.tagsList(projectId), 303);
+      }
+
+      return new Response(null, { status: 204 });
+    },
+  )
+  .openapi(
+    createRoute({
+      summary: "Update tag - UI",
+      method: "get",
+      path: "/projects/{projectId}/tags/{tagId}/update",
+      tags: [tagsTag],
+      request: { params: tagIdPathParams },
+      responses: {
+        200: {
+          description: "UI to upload tag",
+          content: openapiResponsesHtml,
+        },
+        404: {
+          description: "Matching tag not found.",
+          content: openapiErrorResponseContent,
+        },
+        ...openapiCommonErrorResponses,
+      },
+    }),
+    async (context) => {
+      const { ui } = getStore();
+      if (!ui?.renderTagUpdatePage) {
+        throw new HTTPException(405, { message: "UI not available for this route." });
+      }
+
+      const { tagId, projectId } = context.req.valid("param");
+
+      authenticateOrThrow({
+        action: "update",
+        projectId,
+        resource: "tag",
+      });
+
+      const tag = await new TagsModel(projectId).get(tagId);
+      const project = await new ProjectsModel().get(projectId);
+
+      return createUIResultResponse(context, ui.renderTagUpdatePage, { project, tag });
+    },
+  )
+  .openapi(
+    createRoute({
+      summary: "Update tag - action",
+      method: "post",
+      path: "/projects/{projectId}/tags/{tagId}/update",
+      tags: [tagsTag],
+      request: {
+        params: tagIdPathParams,
+        body: {
+          content: { [mimes.formEncoded]: { schema: TagUpdateSchema } },
+          required: true,
+        },
+      },
+      responses: {
+        202: { description: "Tag updated successfully" },
+        303: openapiResponseRedirect("Redirect to tag."),
+        404: {
+          description: "Matching project or tag not found.",
+          content: openapiErrorResponseContent,
+        },
+        415: {
+          content: openapiErrorResponseContent,
+          description: "Unsupported Media Type",
+        },
+        ...openapiCommonErrorResponses,
+      },
+    }),
+    async (context) => {
+      const { tagId, projectId } = context.req.valid("param");
+
+      const tagsModel = new TagsModel(projectId);
+      authenticateOrThrow({
+        action: "update",
+        projectId,
+        resource: "tag",
+      });
+
+      const data = context.req.valid("form");
+      await tagsModel.update(tagId, data);
+
+      if (checkIsHTMLRequest(true)) {
+        return context.redirect(urlBuilder.tagDetails(projectId, tagId), 303);
+      }
+
+      return new Response(null, { status: 202 });
+    },
+  );

package/src/routers/tasks-router.ts

@@ -0,0 +1,75 @@
+import { createRoute, OpenAPIHono, z } from "@hono/zod-openapi";
+import { HTTPException } from "hono/http-exception";
+import { handleProcessZip } from "../handlers/handle-process-zip.ts";
+import { handlePurge } from "../handlers/handle-purge.ts";
+import { buildUploadVariants } from "../models/builds-schema.ts";
+import { urlBuilder } from "../urls.ts";
+import { authenticateOrThrow } from "../utils/auth.ts";
+import { checkIsHTMLRequest } from "../utils/request.ts";
+
+const tasksTag = "Tasks";
+
+const processZipSearchParams = z
+  .object({
+    projectId: z.string(),
+    buildId: z.string(),
+    variant: z.enum(buildUploadVariants),
+  })
+  .loose();
+
+/**
+ * @private
+ */
+export const tasksRouter = new OpenAPIHono()
+  .openapi(
+    createRoute({
+      summary: "Purge outdated builds",
+      method: "post",
+      path: "/purge",
+      tags: [tasksTag],
+      request: { query: z.object({ projectId: z.string() }).partial().loose() },
+      responses: { 204: { description: "Purge complete" } },
+    }),
+    async (context) => {
+      const { projectId } = context.req.valid("query");
+
+      authenticateOrThrow({ action: "update", projectId, resource: "project" });
+      authenticateOrThrow({ action: "delete", projectId, resource: "build" });
+      authenticateOrThrow({ action: "delete", projectId, resource: "tag" });
+
+      await handlePurge({ projectId }, { abortSignal: context.req.raw.signal });
+
+      return new Response(null, { status: 204 });
+    },
+  )
+  .openapi(
+    createRoute({
+      summary: "Process uploaded zip files",
+      method: "post",
+      path: "/process-zip",
+      tags: [tasksTag],
+      request: { query: processZipSearchParams },
+      responses: {
+        204: { description: "Request to process zip file accepter" },
+      },
+    }),
+    async (context) => {
+      const { buildId, projectId, variant } = context.req.valid("query");
+
+      try {
+        await handleProcessZip(projectId, buildId, variant);
+
+        if (checkIsHTMLRequest(true)) {
+          return context.redirect(urlBuilder.buildDetails(projectId, buildId), 303);
+        }
+
+        context.status(204);
+        return context.res;
+      } catch (error) {
+        throw new HTTPException(500, {
+          cause: error,
+          message: "Failed to process uploaded zip file.",
+        });
+      }
+    },
+  );

package/src/types.ts

@@ -0,0 +1,107 @@
+import type { MiddlewareHandler } from "hono";
+import type {
+  AuthAdapter,
+  DatabaseAdapter,
+  LoggerAdapter,
+  StorageAdapter,
+  StoryBookerUser,
+  UIAdapter,
+} from "./adapters/_internal/index.ts";
+import type { ErrorParser } from "./utils/error.ts";
+
+export type {
+  StoryBookerUser,
+  StoryBookerPermissionAction,
+  StoryBookerPermissionKey,
+  StoryBookerPermissionResource,
+  StoryBookerPermissionWithKey,
+} from "./adapters/_internal/auth.ts";
+export type {
+  BuildCreateType,
+  BuildStoryType,
+  BuildType,
+  BuildUpdateType,
+  BuildUploadVariant,
+  BuildsGetResultType,
+  BuildsListResultType,
+} from "./models/builds-schema.ts";
+export type {
+  ProjectCreateType,
+  ProjectGetResultType,
+  ProjectUpdateType,
+  ProjectType,
+  ProjectsListResultType,
+} from "./models/projects-schema.ts";
+export type {
+  TagCreateType,
+  TagType,
+  TagUpdateType,
+  TagVariant,
+  TagsGetResultType,
+  TagsListResultType,
+} from "./models/tags-schema.ts";
+export type { ErrorParser, ParsedError } from "./utils/error.ts";
+export type { UrlBuilder } from "./urls.ts";
+
+/**
+ * Options for creating a router.
+ */
+export interface RouterOptions<User extends StoryBookerUser> {
+  /** Adapter for Auth service. Provides authentication to the service. */
+  auth?: AuthAdapter<User>;
+  /** Adapter for Database service. Provides access to storing data to the service. */
+  database: DatabaseAdapter;
+  /** Additional options to configure the router. */
+  config?: RouterConfig;
+  /** Adapter for Logging service. Provides option to direct the logging of the service. */
+  logger?: LoggerAdapter;
+  /** Adapter for Storage service. Provides access to storing files to the service. */
+  storage: StorageAdapter;
+  /** Options to customise StoryBooker UI. */
+  ui?: UIAdapter;
+}
+
+/**
+ * Options for creating a purge handler.
+ */
+export interface PurgeHandlerOptions {
+  /** Adapter for Database service. Provides access to storing data to the service. */
+  database: DatabaseAdapter;
+  /**
+   * A function for parsing custom errors.
+   * Return `undefined` from parser if the service should handle the error.
+   */
+  errorParser?: ErrorParser;
+  /** Adapter for Logging service. Provides option to direct the logging of the service. */
+  logger?: LoggerAdapter;
+  /** Adapter for Storage service. Provides access to storing files to the service. */
+  storage: StorageAdapter;
+}
+
+/** Additional options to configure the router. */
+export interface RouterConfig {
+  /**
+   * A function for parsing custom errors.
+   * Return `undefined` from parser if the service should handle the error.
+   */
+  errorParser?: ErrorParser;
+  /**
+   * Maximum upload size in bytes for processing zip files while uploading.
+   * @default "5 * 1024 * 1024" (5MB)
+   */
+  maxInlineUploadProcessingSizeInBytes?: number;
+  /**
+   * Enable queueing of zip file processing for files larger than the maximum inline upload processing size.
+   * Requires QueueAdapter and other setup.
+   * @default false
+   */
+  queueLargeZipFileProcessing?: boolean;
+  /**
+   * Convey URL prefix to the service if the router is not hosted on the root.
+   */
+  prefix?: string;
+  /**
+   * Add Hono middlewares to the router before any endpoint is registered/invoked.
+   */
+  middlewares?: MiddlewareHandler[];
+}