storybooker 0.19.4 → 0.22.0-canary.0

package/src/urls.ts

@@ -0,0 +1,327 @@
+import path from "node:path";
+import type { BuildUploadVariant } from "./models/builds-schema.ts";
+import type { TagVariant } from "./models/tags-schema.ts";
+import { getStore } from "./utils/store.ts";
+import { linkRoute, urlJoin } from "./utils/url-utils.ts";
+
+/**
+ * URL builder for the Storybooks router.
+ */
+export class UrlBuilder {
+  #useStore: boolean;
+
+  constructor(useStore: boolean) {
+    this.#useStore = useStore;
+  }
+
+  get #baseUrl(): string {
+    if (!this.#useStore) {
+      return "";
+    }
+
+    return new URL(getStore().url).origin;
+  }
+
+  homepage(): string {
+    return linkRoute((client) => client.index.$url(), {
+      baseUrl: this.#baseUrl,
+    });
+  }
+  openapi(): string {
+    return linkRoute((client) => client.openapi.$url(), {
+      baseUrl: this.#baseUrl,
+    });
+  }
+  staticFile(filepath: string): string {
+    return linkRoute((client) => client[":filepath{.+}"].$url({ param: { filepath } }), {
+      baseUrl: this.#baseUrl,
+    });
+  }
+
+  // accounts
+  account(): string {
+    return linkRoute((client) => client.account.$url(), {
+      baseUrl: this.#baseUrl,
+    });
+  }
+
+  login(redirect?: string): string {
+    return linkRoute((client) => client.account.login.$url({ query: { redirect } }), {
+      baseUrl: this.#baseUrl,
+    });
+  }
+  logout(): string {
+    return linkRoute((client) => client.account.logout.$url(), {
+      baseUrl: this.#baseUrl,
+    });
+  }
+
+  // projects
+  projectsList(): string {
+    return linkRoute((client) => client.projects.$url(), {
+      baseUrl: this.#baseUrl,
+    });
+  }
+  projectCreate(): string {
+    return linkRoute((client) => client.projects.create.$url(), {
+      baseUrl: this.#baseUrl,
+    });
+  }
+  projectDetails(projectId: string): string {
+    return linkRoute((client) => client.projects[":projectId"].$url({ param: { projectId } }), {
+      baseUrl: this.#baseUrl,
+    });
+  }
+  projectUpdate(projectId: string): string {
+    return linkRoute(
+      (client) => client.projects[":projectId"].update.$url({ param: { projectId } }),
+      { baseUrl: this.#baseUrl },
+    );
+  }
+  projectDelete(projectId: string): string {
+    return linkRoute(
+      (client) => client.projects[":projectId"].delete.$url({ param: { projectId } }),
+      { baseUrl: this.#baseUrl },
+    );
+  }
+
+  // builds
+  buildsList(projectId: string): string {
+    return linkRoute(
+      (client) => client.projects[":projectId"].builds.$url({ param: { projectId } }),
+      { baseUrl: this.#baseUrl },
+    );
+  }
+  buildDetails(projectId: string, buildId: string): string {
+    return linkRoute(
+      (client) =>
+        client.projects[":projectId"].builds[":buildId"].$url({
+          param: { buildId, projectId },
+        }),
+      { baseUrl: this.#baseUrl },
+    );
+  }
+  buildCreate(projectId: string, tagId?: string): string {
+    return linkRoute(
+      (client) =>
+        client.projects[":projectId"].builds.create.$url({
+          param: { projectId },
+          query: { tagId },
+        }),
+      { baseUrl: this.#baseUrl },
+    );
+  }
+  buildDelete(projectId: string, buildId: string): string {
+    return linkRoute(
+      (client) =>
+        client.projects[":projectId"].builds[":buildId"].delete.$url({
+          param: { projectId, buildId },
+        }),
+      { baseUrl: this.#baseUrl },
+    );
+  }
+  buildUpdate(projectId: string, buildId: string): string {
+    return linkRoute(
+      (client) =>
+        client.projects[":projectId"].builds[":buildId"].update.$url({
+          param: { projectId, buildId },
+        }),
+      { baseUrl: this.#baseUrl },
+    );
+  }
+  buildUpload(projectId: string, buildId: string, variant?: BuildUploadVariant): string {
+    return linkRoute(
+      (client) =>
+        client.projects[":projectId"].builds[":buildId"].upload.$url({
+          param: { buildId, projectId },
+          query: { variant },
+        }),
+      { baseUrl: this.#baseUrl },
+    );
+  }
+
+  // tags
+  tagsList(projectId: string, type?: TagVariant): string {
+    return linkRoute(
+      (client) =>
+        client.projects[":projectId"].tags.$url({
+          param: { projectId },
+          query: { type },
+        }),
+      { baseUrl: this.#baseUrl },
+    );
+  }
+  tagCreate(projectId: string): string {
+    return linkRoute(
+      (client) =>
+        client.projects[":projectId"].tags.create.$url({
+          param: { projectId },
+        }),
+      { baseUrl: this.#baseUrl },
+    );
+  }
+  tagDetails(projectId: string, tagId: string): string {
+    return linkRoute(
+      (client) =>
+        client.projects[":projectId"].tags[":tagId"].$url({
+          param: { projectId, tagId },
+        }),
+      { baseUrl: this.#baseUrl },
+    );
+  }
+  tagDelete(projectId: string, tagId: string): string {
+    return linkRoute(
+      (client) =>
+        client.projects[":projectId"].tags[":tagId"].delete.$url({
+          param: { projectId, tagId },
+        }),
+      { baseUrl: this.#baseUrl },
+    );
+  }
+  tagUpdate(projectId: string, tagId: string): string {
+    return linkRoute(
+      (client) =>
+        client.projects[":projectId"].tags[":tagId"].update.$url({
+          param: { projectId, tagId },
+        }),
+      { baseUrl: this.#baseUrl },
+    );
+  }
+  // tagLatest: (projectId: string, tagId: string): string => {
+  //   return linkRoute((client) =>
+  //     client.projects[":projectId"].tags[":tagId"].latest.$url({
+  //       param: { projectId, tagId },
+  //     }),
+  //   );
+  // },
+
+  // tasks
+  taskPurge(projectId?: string): string {
+    return linkRoute((client) => client.tasks.purge.$url({ query: { projectId } }), {
+      baseUrl: this.#baseUrl,
+    });
+  }
+  taskProcessZip(projectId: string, buildId: string, variant: BuildUploadVariant): string {
+    return linkRoute(
+      (client) =>
+        client.tasks["process-zip"].$url({
+          query: { projectId, buildId, variant },
+        }),
+      { baseUrl: this.#baseUrl },
+    );
+  }
+
+  // serve
+  storybookIndexHtml(projectId: string, buildId: string, storyId?: string): string {
+    return linkRoute(
+      (client) =>
+        client._[":projectId"][":buildId"][":filepath{.+}"].$url({
+          param: {
+            projectId,
+            buildId,
+            filepath: "storybook/index.html",
+          },
+          query: {
+            path: storyId ? `/story/${storyId}` : undefined,
+          },
+        }),
+      { baseUrl: this.#baseUrl },
+    );
+  }
+  storybookIFrameHtml(projectId: string, buildId: string, storyId: string): string {
+    return linkRoute(
+      (client) =>
+        client._[":projectId"][":buildId"][":filepath{.+}"].$url({
+          param: {
+            projectId,
+            buildId,
+            filepath: "storybook/iframe.html",
+          },
+          query: { id: storyId, viewMode: "story" },
+        }),
+      { baseUrl: this.#baseUrl },
+    );
+  }
+  storybookDownload(projectId: string, buildId: string): string {
+    return linkRoute(
+      (client) =>
+        client._[":projectId"][":buildId"][":filepath{.+}"].$url({
+          param: {
+            projectId,
+            buildId,
+            filepath: "storybook.zip",
+          },
+          query: {},
+        }),
+      { baseUrl: this.#baseUrl },
+    );
+  }
+  storybookTestReport(projectId: string, buildId: string): string {
+    return linkRoute(
+      (client) =>
+        client._[":projectId"][":buildId"][":filepath{.+}"].$url({
+          param: {
+            projectId,
+            buildId,
+            filepath: "testReport/index.html",
+          },
+          query: {},
+        }),
+      { baseUrl: this.#baseUrl },
+    );
+  }
+  storybookCoverage(projectId: string, buildId: string): string {
+    return linkRoute(
+      (client) =>
+        client._[":projectId"][":buildId"][":filepath{.+}"].$url({
+          param: {
+            projectId,
+            buildId,
+            filepath: "coverage/index.html",
+          },
+          query: {},
+        }),
+      { baseUrl: this.#baseUrl },
+    );
+  }
+  storybookScreenshot(projectId: string, buildId: string, ...filename: string[]): string {
+    return linkRoute(
+      (client) =>
+        client._[":projectId"][":buildId"][":filepath{.+}"].$url({
+          param: {
+            projectId,
+            buildId,
+            filepath: path.posix.join("screenshots", ...filename),
+          },
+          query: {},
+        }),
+      { baseUrl: this.#baseUrl },
+    );
+  }
+  storybookScreenshotsDownload(projectId: string, buildId: string): string {
+    return linkRoute(
+      (client) =>
+        client._[":projectId"][":buildId"][":filepath{.+}"].$url({
+          param: {
+            projectId,
+            buildId,
+            filepath: "screenshots.zip",
+          },
+          query: {},
+        }),
+      { baseUrl: this.#baseUrl },
+    );
+  }
+
+  // external
+  // oxlint-disable-next-line class-methods-use-this
+  gitHub(gitHubRepo: string, ...pathnames: string[]): string {
+    const url = new URL(urlJoin(gitHubRepo, ...pathnames), "https://github.com");
+    return url.toString();
+  }
+}
+
+/** @private */
+export const urlBuilder: UrlBuilder = new UrlBuilder(true);
+/** @private */
+export const urlBuilderWithoutStore: UrlBuilder = new UrlBuilder(false);

package/src/utils/adapter-utils.ts

@@ -0,0 +1,26 @@
+import { SERVICE_NAME } from "../utils/constants.ts";
+
+export function generateDatabaseCollectionId(
+  projectId: string,
+  suffix: "Tags" | "Builds" | "",
+): string {
+  if (!suffix) {
+    return `${SERVICE_NAME}-${projectId}`;
+  }
+
+  return `${SERVICE_NAME}-${projectId}-${suffix}`;
+}
+
+export function generateStorageContainerId(projectId: string): string {
+  return `${SERVICE_NAME}-${projectId}`;
+}
+
+/**
+ * Metadata information about a StoryBooker adapter.
+ */
+export interface StoryBookerAdapterMetadata {
+  name: string;
+  description?: string;
+  version?: string;
+  [key: string]: unknown;
+}

package/src/utils/auth.test.ts

@@ -0,0 +1,71 @@
+import { HTTPException } from "hono/http-exception";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { mockUser } from "../mocks/mock-auth-service";
+import { mockStore } from "../mocks/mock-store";
+import { authenticateOrThrow, checkAuthorisation } from "./auth";
+import { getStore } from "./store";
+
+vi.mock("./store");
+
+describe("authenticateOrThrow", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("allows all actions if no auth service", () => {
+    vi.mocked(getStore).mockReturnValue({ ...mockStore, auth: undefined });
+    const actual = authenticateOrThrow({
+      resource: "build",
+      action: "delete",
+    });
+
+    expect(actual).toBeUndefined();
+  });
+
+  it("throws 401 if user is missing", () => {
+    vi.mocked(getStore).mockReturnValue({
+      ...mockStore,
+      user: null,
+    });
+
+    expect(() => {
+      authenticateOrThrow({ resource: "build", action: "delete" });
+    }).toThrow(HTTPException);
+  });
+
+  it("returns if auth.authorise returns true", () => {
+    vi.mocked(getStore).mockReturnValue(mockStore);
+    expect(authenticateOrThrow({ resource: "build", action: "delete" })).toBeUndefined();
+  });
+
+  it("throws 403 if user is not authorised", () => {
+    vi.mocked(getStore).mockReturnValue({
+      ...mockStore,
+      user: { ...mockUser, permissions: { ...mockUser.permissions, "build:delete": false } },
+    });
+
+    expect(() => {
+      authenticateOrThrow({ resource: "build", action: "delete" });
+    }).toThrow(HTTPException);
+  });
+});
+
+describe("checkAuthorisation", () => {
+  it("returns true if no auth service", () => {
+    vi.mocked(getStore).mockReturnValue({ ...mockStore, auth: undefined });
+    expect(checkAuthorisation({ resource: "build", action: "delete" })).toBe(true);
+  });
+
+  it("returns true if user is authorised", () => {
+    vi.mocked(getStore).mockReturnValue(mockStore);
+    expect(checkAuthorisation({ resource: "build", action: "delete" })).toBe(true);
+  });
+
+  it("returns false if user is not authorised", () => {
+    vi.mocked(getStore).mockReturnValue({
+      ...mockStore,
+      user: { ...mockUser, permissions: { ...mockUser.permissions, "build:delete": false } },
+    });
+    expect(checkAuthorisation({ resource: "build", action: "delete" })).toBe(false);
+  });
+});

package/src/utils/auth.ts

@@ -0,0 +1,39 @@
+import { HTTPException } from "hono/http-exception";
+import type {
+  StoryBookerPermission,
+  StoryBookerPermissionKey,
+} from "../adapters/_internal/auth.ts";
+import { getStore } from "../utils/store.ts";
+
+export function authenticateOrThrow(permission: StoryBookerPermission): void {
+  const { auth, logger, user } = getStore();
+  if (!auth) {
+    // No authentication service configured, allow all actions
+    return;
+  }
+
+  if (!user) {
+    throw new HTTPException(401, { message: "Unauthenticated. Please log in to continue." });
+  }
+
+  const key: StoryBookerPermissionKey = `${permission.resource}:${permission.action}`;
+  logger.debug?.("[Auth] Check authorisation for '%s'", key);
+
+  // Authorized
+  const hasPermission = user.permissions[key];
+
+  if (hasPermission) {
+    return;
+  }
+
+  throw new HTTPException(403, { message: `Permission denied [${key}]` });
+}
+
+export function checkAuthorisation(permission: StoryBookerPermission): boolean {
+  try {
+    authenticateOrThrow(permission);
+    return true;
+  } catch {
+    return false;
+  }
+}

package/src/utils/constants.ts

@@ -0,0 +1,31 @@
+export const SERVICE_NAME = "StoryBooker";
+export const SERVICE_SHORT_NAME = "SBR";
+export const CACHE_CONTROL_PUBLIC_YEAR = "public, max-age=31536000, immutable";
+
+export const DEFAULT_PURGE_AFTER_DAYS = 30;
+export const DEFAULT_GITHUB_BRANCH = "main";
+export const ONE_DAY_IN_MS: number = 24 * 60 * 60 * 1000;
+export const DEFAULT_LOCALE = "en";
+
+export const QUERY_PARAMS = {
+  tagId: "tagId",
+  uploadVariant: "variant",
+  redirect: "redirect",
+} as const;
+
+export const PATTERNS = {
+  projectId: {
+    message: "Should contain only lowercase alphabets, numbers and hyphen.",
+    pattern: "^[a-z0-9][a-z0-9-]{0,60}$",
+  },
+} satisfies Record<
+  string,
+  {
+    pattern: string | RegExp;
+    patternGlobal?: string | RegExp;
+    message?: string;
+  }
+>;
+
+export const TagTypes = ["branch", "pr", "jira"] as const;
+export const buildUploadVariants = ["storybook", "testReport", "coverage", "screenshots"] as const;

package/src/utils/date-utils.ts

@@ -0,0 +1,10 @@
+import { getStore } from "./store";
+
+export function renderLocalTime(
+  value: string | Date | number,
+  options?: Intl.DateTimeFormatOptions,
+): string {
+  const { locale } = getStore();
+
+  return new Date(value).toLocaleString(locale, options);
+}

package/src/utils/error.test.ts

@@ -0,0 +1,86 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { z } from "zod";
+import { mockStore } from "../mocks/mock-store";
+import { parseErrorMessage } from "./error";
+
+// Mock #store and getStoreOrNull
+vi.mock("./store", () => ({
+  getStoreOrNull: vi.fn(),
+}));
+
+const { getStoreOrNull } = await import("./store");
+
+describe("parseErrorMessage", () => {
+  beforeEach(() => {
+    vi.resetAllMocks();
+  });
+
+  it("returns custom error if errorParser is provided", () => {
+    const customParser = vi.fn().mockReturnValue({
+      errorMessage: "custom",
+      errorType: "custom",
+    });
+    const result = parseErrorMessage("err", customParser);
+    expect(result).toEqual({ errorMessage: "custom", errorType: "custom" });
+    expect(customParser).toHaveBeenCalledWith("err");
+  });
+
+  it("returns custom error if errorParser from store is provided", () => {
+    vi.mocked(getStoreOrNull).mockReturnValue({
+      ...mockStore,
+      errorParser: vi.fn().mockReturnValue({
+        errorMessage: "store",
+        errorType: "store",
+      }),
+    });
+    const result = parseErrorMessage("err");
+    expect(result).toEqual({ errorMessage: "store", errorType: "store" });
+  });
+
+  it("returns string error", () => {
+    vi.mocked(getStoreOrNull).mockReturnValue(mockStore);
+    const result = parseErrorMessage("simple error");
+    expect(result).toEqual({
+      errorMessage: "simple error",
+      errorType: "string",
+    });
+  });
+
+  it("returns Zod error", () => {
+    vi.mocked(getStoreOrNull).mockReturnValue(mockStore);
+    const schema = z.object({ foo: z.string() });
+    let newError: unknown = null;
+    try {
+      schema.parse({ foo: 123 });
+    } catch (error) {
+      newError = error;
+    }
+
+    const result = parseErrorMessage(newError);
+    expect(result).toEqual({
+      errorMessage: "✖ Invalid input: expected string, received number\n  → at foo",
+      errorStatus: 400,
+      errorType: "Zod",
+    });
+  });
+
+  it("returns Error object", () => {
+    vi.mocked(getStoreOrNull).mockReturnValue(mockStore);
+    const err = new Error("fail");
+    const result = parseErrorMessage(err);
+    expect(result).toEqual({ errorMessage: "fail", errorType: "error" });
+  });
+
+  it("returns error with message property", () => {
+    vi.mocked(getStoreOrNull).mockReturnValue(mockStore);
+    const err = { message: "msg" };
+    const result = parseErrorMessage(err);
+    expect(result).toEqual({ errorMessage: "msg", errorType: "error" });
+  });
+
+  it("returns unknown error", () => {
+    vi.mocked(getStoreOrNull).mockReturnValue(mockStore);
+    const result = parseErrorMessage(12_345);
+    expect(result).toEqual({ errorMessage: "12345", errorType: "unknown" });
+  });
+});