storybooker 0.19.3 → 0.22.0-canary.0

package/src/models/tags-model.ts

@@ -0,0 +1,138 @@
+import { HTTPException } from "hono/http-exception";
+import type { StoryBookerPermissionAction } from "../adapters/_internal/auth.ts";
+import { generateDatabaseCollectionId } from "../utils/adapter-utils.ts";
+import { checkAuthorisation } from "../utils/auth.ts";
+import { BuildsModel } from "./builds-model.ts";
+import { ProjectsModel } from "./projects-model.ts";
+import { TagSchema, type TagCreateType, type TagType, type TagUpdateType } from "./tags-schema.ts";
+import { Model, type BaseModel, type ListOptions } from "./~model.ts";
+
+export class TagsModel extends Model<TagType> {
+  constructor(projectId: string) {
+    super(projectId, generateDatabaseCollectionId(projectId, "Tags"));
+  }
+
+  async list(options: ListOptions<TagType> = {}): Promise<TagType[]> {
+    this.log("List tags...");
+
+    const items = await this.database.listDocuments(this.collectionId, options, this.dbOptions);
+
+    return TagSchema.array().parse(items);
+  }
+
+  async create(data: TagCreateType, withBuild = false): Promise<TagType> {
+    this.log("Create tag '%s'...", data.value);
+    const id = TagsModel.createId(data.value);
+
+    try {
+      if (await this.has(id)) {
+        throw new HTTPException(409, {
+          message: `Tag '${id}' already exists.`,
+        });
+      }
+
+      const now = new Date().toISOString();
+      const tag: TagType = {
+        ...data,
+        buildsCount: withBuild ? 1 : 0,
+        createdAt: now,
+        id: id,
+        updatedAt: now,
+      };
+      await this.database.createDocument(this.collectionId, tag, this.dbOptions);
+
+      return tag;
+    } catch (error) {
+      throw new HTTPException(500, {
+        cause: error,
+        message: `Failed to create tag '${id}'.`,
+      });
+    }
+  }
+
+  async get(id: string): Promise<TagType> {
+    this.log("Get tag '%s'...", id);
+
+    const item = await this.database.getDocument(this.collectionId, id, this.dbOptions);
+
+    return TagSchema.parse(item);
+  }
+
+  async has(id: string): Promise<boolean> {
+    this.log("Check tag '%s'...", id);
+    try {
+      return await this.database.hasDocument(this.collectionId, id, this.dbOptions);
+    } catch {
+      return false;
+    }
+  }
+
+  async update(id: string, data: TagUpdateType): Promise<void> {
+    this.log("Update tag '%s'...", id);
+
+    await this.database.updateDocument(
+      this.collectionId,
+      id,
+      { ...data, updatedAt: new Date().toISOString() },
+      this.dbOptions,
+    );
+  }
+
+  async delete(id: string): Promise<void> {
+    this.log("Delete tag '%s'...", id);
+
+    const { gitHubDefaultBranch } = await new ProjectsModel().get(this.projectId);
+    if (id === TagsModel.createId(gitHubDefaultBranch)) {
+      const message = `Cannot delete the tag associated with default branch (${gitHubDefaultBranch}) of the project '${this.projectId}'.`;
+      this.error(message);
+      throw new Error(message);
+    }
+
+    await this.database.deleteDocument(this.collectionId, id, this.dbOptions);
+
+    try {
+      this.debug("Delete builds associated with tag '%s'...", id);
+      await new BuildsModel(this.projectId).deleteByTag(id, false);
+    } catch (error) {
+      this.error("Error deleting builds associated with tag:", error);
+    }
+  }
+
+  checkAuth = (action: StoryBookerPermissionAction): boolean => {
+    return checkAuthorisation({
+      action,
+      projectId: this.projectId,
+      resource: "tag",
+    });
+  };
+
+  id: BaseModel<TagType>["id"] = (id: string) => {
+    return {
+      checkAuth: (action) =>
+        checkAuthorisation({
+          action,
+          projectId: this.projectId,
+          resource: "tag",
+        }),
+      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),
+    };
+  };
+
+  static createId(value: string): string {
+    return value.trim().toLowerCase().replace(/\W+/, "-");
+  }
+
+  static guessType(id: string): TagType["type"] {
+    if (/^\d+$/.test(id)) {
+      return "pr";
+    }
+    if (/^\w+-\d+$/.test(id)) {
+      return "jira";
+    }
+    return "branch";
+  }
+}

package/src/models/tags-schema.ts

@@ -0,0 +1,45 @@
+import { z } from "@hono/zod-openapi";
+import { TagTypes } from "../utils/constants.ts";
+import { BuildIdSchema, TagIdSchema } from "./~shared-schema.ts";
+
+export { TagIdSchema, TagTypes };
+
+export type TagVariant = (typeof TagTypes)[number];
+
+export type TagType = z.infer<typeof TagSchema>;
+export const TagSchema = z
+  .object({
+    buildsCount: z.number().default(0),
+    createdAt: z.iso.datetime().default(new Date().toISOString()),
+    id: TagIdSchema,
+    latestBuildId: z.union([BuildIdSchema.optional(), z.literal("")]),
+    type: z.enum(TagTypes),
+    updatedAt: z.iso.datetime().default(new Date().toISOString()),
+    value: z.string().meta({ description: "The value of the tag." }),
+  })
+  .meta({ id: "Tag", title: "StoryBooker Tag" });
+
+export type TagCreateType = z.infer<typeof TagCreateSchema>;
+export const TagCreateSchema = TagSchema.omit({
+  buildsCount: true,
+  createdAt: true,
+  id: true,
+
+  updatedAt: true,
+});
+
+export type TagUpdateType = z.infer<typeof TagUpdateSchema>;
+export const TagUpdateSchema = TagSchema.omit({
+  createdAt: true,
+  id: true,
+  updatedAt: true,
+}).partial();
+
+export type TagsListResultType = z.infer<typeof TagsListResultSchema>;
+export const TagsListResultSchema = z.object({
+  tags: TagSchema.array(),
+});
+export type TagsGetResultType = z.infer<typeof TagsGetResultSchema>;
+export const TagsGetResultSchema = z.object({
+  tag: TagSchema,
+});

package/src/models/~model.ts

@@ -0,0 +1,79 @@
+import type {
+  DatabaseAdapter,
+  DatabaseAdapterOptions,
+  LoggerAdapter,
+  StorageAdapter,
+  StorageAdapterOptions,
+  StoryBookerDatabaseDocument,
+  StoryBookerPermissionAction,
+} from "../adapters/_internal/index.ts";
+import { parseErrorMessage } from "../utils/error.ts";
+import { getStore } from "../utils/store.ts";
+
+export interface ListOptions<Item extends Record<string, unknown>> {
+  limit?: number;
+  filter?: string | ((item: Item) => boolean);
+  select?: string[];
+  sort?: "latest" | ((item1: Item, item2: Item) => number);
+}
+
+export abstract class Model<Data extends StoryBookerDatabaseDocument> implements BaseModel<Data> {
+  projectId: string;
+  collectionId: string;
+  database: DatabaseAdapter<Data>;
+  storage: StorageAdapter;
+  logger: LoggerAdapter;
+  dbOptions: DatabaseAdapterOptions;
+  storageOptions: StorageAdapterOptions;
+
+  constructor(projectId: string | null, collectionId: string) {
+    const { abortSignal, database, storage, logger } = getStore();
+    this.projectId = projectId ?? "";
+    this.collectionId = collectionId;
+    this.database = database as unknown as DatabaseAdapter<Data>;
+    this.storage = storage;
+    this.logger = logger;
+    this.dbOptions = { abortSignal, logger };
+    this.storageOptions = { abortSignal, logger };
+  }
+
+  log(message: string, ...args: unknown[]): void {
+    this.logger.log(`[Model:${this.projectId || "All"}] ${message}`, ...args);
+  }
+  debug(message: string, ...args: unknown[]): void {
+    this.logger.debug?.(`[Model:${this.projectId || "All"}] ${message}`, ...args);
+  }
+  error(error: unknown, ...args: unknown[]): void {
+    const { errorMessage } = parseErrorMessage(error);
+    this.logger.error(`[Model:${this.projectId || "All"}] Error:`, errorMessage, ...args);
+  }
+
+  abstract list(options?: ListOptions<Data>): Promise<Data[]>;
+  abstract create(data: unknown): Promise<Data>;
+  abstract get(id: string): Promise<Data>;
+  abstract has(id: string): Promise<boolean>;
+  abstract update(id: string, data: unknown): Promise<void>;
+  abstract delete(id: string): Promise<void>;
+  abstract id: (id: string) => BaseIdModel<Data>;
+  abstract checkAuth(action: StoryBookerPermissionAction): boolean;
+}
+
+export interface BaseModel<Data extends StoryBookerDatabaseDocument> {
+  list(options?: ListOptions<Data>): Promise<Data[]>;
+  create(data: unknown): Promise<Data>;
+  get(id: string): Promise<Data>;
+  has(id: string): Promise<boolean>;
+  update(id: string, data: unknown): Promise<void>;
+  delete(id: string): Promise<void>;
+  checkAuth(action: StoryBookerPermissionAction): boolean;
+  id: (id: string) => BaseIdModel<Data>;
+}
+
+export interface BaseIdModel<Data extends StoryBookerDatabaseDocument> {
+  id: string;
+  get(): Promise<Data>;
+  has(): Promise<boolean>;
+  update(data: unknown): Promise<void>;
+  delete(): Promise<void>;
+  checkAuth(action: StoryBookerPermissionAction): boolean;
+}

package/src/models/~shared-schema.ts

@@ -0,0 +1,14 @@
+import { z } from "@hono/zod-openapi";
+import { PATTERNS } from "../utils/constants.ts";
+
+export const TagIdSchema = z.string().meta({ description: "The ID of the tag.", id: "TagID" });
+
+export const BuildIdSchema = z
+  .string()
+  .check(z.minLength(7))
+  .meta({ description: "The ID of the build.", id: "BuildID" });
+
+export const ProjectIdSchema = z
+  .string()
+  .refine((val) => new RegExp(PATTERNS.projectId.pattern).test(val), PATTERNS.projectId.message)
+  .meta({ description: "The ID of the project.", id: "ProjectID" });

package/src/routers/_app-router.ts

@@ -0,0 +1,57 @@
+import { swaggerUI } from "@hono/swagger-ui";
+import { OpenAPIHono, type OpenAPIObjectConfigure } from "@hono/zod-openapi";
+import type { Context, Env } from "hono";
+import { SERVICE_NAME } from "../utils/constants.ts";
+import { getStore } from "../utils/store.ts";
+import { createUIAdapterOptions } from "../utils/ui-utils.ts";
+import { accountRouter } from "./account-router.ts";
+import { buildsRouter } from "./builds-router.ts";
+import { projectsRouter } from "./projects-router.ts";
+import { rootRouter } from "./root-router.ts";
+import { tagsRouter } from "./tags-router.ts";
+import { tasksRouter } from "./tasks-router.ts";
+
+type OpenAPIObjectConfig<Configure extends OpenAPIObjectConfigure<Env, "">> = Configure extends (
+  context: Context,
+) => infer Config
+  ? Config
+  : Configure;
+/**
+ * @private
+ */
+export const openapiConfig: OpenAPIObjectConfig<OpenAPIObjectConfigure<Env, "">> = {
+  openapi: "3.1.0",
+  info: { title: SERVICE_NAME, version: "" },
+};
+
+/**
+ * @private
+ */
+export type AppRouter = typeof appRouter;
+
+/**
+ * @private
+ */
+export const appRouter = new OpenAPIHono({ strict: false })
+  .doc31("/openapi.json", openapiConfig)
+  .get("/openapi.yaml", async (ctx) => {
+    const spec = (appRouter as OpenAPIHono).getOpenAPI31Document(openapiConfig);
+    const dumpYaml = await import("js-yaml").then((mod) => mod.dump);
+    const content: string = dumpYaml(spec, { forceQuotes: true });
+    return ctx.body(content, 200, { "Content-Type": "application/yaml" });
+  })
+  .get("/openapi", swaggerUI({ url: "/openapi.json" }))
+  .route("/", rootRouter)
+  .route("/", projectsRouter)
+  .route("/", buildsRouter)
+  .route("/", tagsRouter)
+  .route("/tasks", tasksRouter)
+  .route("/account", accountRouter)
+  .get("/:filepath{.+}", async (context) => {
+    const { ui } = getStore();
+    if (!ui?.handleUnhandledRoute) {
+      return context.notFound();
+    }
+
+    return await ui.handleUnhandledRoute(context.req.param("filepath"), createUIAdapterOptions());
+  });

package/src/routers/account-router.ts

@@ -0,0 +1,136 @@
+import { createRoute, OpenAPIHono, z } from "@hono/zod-openapi";
+import { HTTPException } from "hono/http-exception";
+import { urlBuilder } from "../urls.ts";
+import { QUERY_PARAMS } from "../utils/constants.ts";
+import {
+  openapiCommonErrorResponses,
+  openapiResponseRedirect,
+  openapiResponsesHtml,
+} from "../utils/openapi-utils.ts";
+import { getStore } from "../utils/store.ts";
+import { createUIResultResponse } from "../utils/ui-utils.ts";
+
+const accountTag = "Account";
+
+/**
+ * @private
+ */
+export const accountRouter = new OpenAPIHono()
+  .openapi(
+    createRoute({
+      summary: "Account page",
+      method: "get",
+      path: "/",
+      tags: [accountTag],
+      responses: {
+        200: {
+          description: "Render account page",
+          content: openapiResponsesHtml,
+        },
+        ...openapiCommonErrorResponses,
+      },
+    }),
+    async (context) => {
+      const { abortSignal, auth, logger, request, user, ui } = getStore();
+
+      if (!auth) {
+        throw new HTTPException(500, { message: "Auth is not setup" });
+      }
+
+      if (!user) {
+        const { pathname } = new URL(urlBuilder.account());
+        return context.redirect(urlBuilder.login(pathname), 302);
+      }
+
+      if (!ui?.renderAccountsPage) {
+        throw new HTTPException(405, { message: "UI is not available for this route." });
+      }
+
+      const children = await auth.renderAccountDetails?.(user, {
+        abortSignal,
+        logger,
+        request,
+      });
+
+      return createUIResultResponse(context, ui.renderAccountsPage, { children });
+    },
+  )
+  .openapi(
+    createRoute({
+      summary: "Login to account",
+      method: "get",
+      path: "/login",
+      tags: [accountTag],
+      request: {
+        query: z
+          .object({ [QUERY_PARAMS.redirect]: z.string() })
+          .partial()
+          .loose(),
+      },
+      responses: {
+        302: openapiResponseRedirect("Login successful"),
+        ...openapiCommonErrorResponses,
+      },
+    }),
+    async (context) => {
+      const { abortSignal, auth, logger, request } = getStore();
+
+      if (!auth) {
+        throw new HTTPException(500, { message: "Auth is not setup" });
+      }
+
+      const response = await auth.login({ abortSignal, logger, request });
+
+      if (response.status >= 400) {
+        return response;
+      }
+
+      const { redirect = "" } = context.req.valid("query");
+      const location = new URL(redirect, urlBuilder.homepage());
+      for (const [key, value] of response.headers) {
+        context.res.headers.set(key, value);
+      }
+
+      return context.redirect(location.toString());
+    },
+  )
+  .openapi(
+    createRoute({
+      summary: "Logout from account",
+      method: "get",
+      path: "/logout",
+      tags: [accountTag],
+      responses: {
+        302: openapiResponseRedirect("Logout successful"),
+        ...openapiCommonErrorResponses,
+      },
+    }),
+    async (context) => {
+      const { abortSignal, auth, logger, request, user } = getStore();
+      if (!auth) {
+        throw new HTTPException(500, { message: "Auth is not setup" });
+      }
+
+      if (!user) {
+        throw new HTTPException(401, { message: "User is not authenticated" });
+      }
+
+      const response = await auth.logout(user, {
+        abortSignal,
+        logger,
+        request,
+      });
+      if (response.status >= 400) {
+        return response;
+      }
+
+      const responseHeaders = new Headers(response.headers);
+      const responseLocation = responseHeaders.get("location");
+      responseHeaders.delete("location");
+      for (const [key, value] of responseHeaders) {
+        context.res.headers.set(key, value);
+      }
+
+      return context.redirect(responseLocation ?? urlBuilder.homepage());
+    },
+  );