storybooker 0.19.4 → 0.22.0-canary.0

package/src/utils/store.ts

@@ -0,0 +1,85 @@
+import { SuperHeaders } from "@remix-run/headers";
+import type { MiddlewareHandler } from "hono";
+import { endTime, startTime } from "hono/timing";
+import { AsyncLocalStorage } from "node:async_hooks";
+import {
+  createConsoleLoggerAdapter,
+  type AuthAdapter,
+  type LoggerAdapter,
+} from "../adapters/_internal/index.ts";
+import type { RouterOptions, StoryBookerUser } from "../types.ts";
+import type { ErrorParser } from "../utils/error.ts";
+import { DEFAULT_LOCALE } from "./constants.ts";
+
+export interface Store extends RouterOptions<StoryBookerUser> {
+  abortSignal: AbortSignal | undefined;
+  errorParser?: ErrorParser;
+  headers: SuperHeaders;
+  locale: string;
+  logger: LoggerAdapter;
+  prefix: string;
+  request: Request;
+  url: string;
+  user: StoryBookerUser | null | undefined;
+}
+
+export const localStore = new AsyncLocalStorage<Store>();
+
+export function getStore(): Store {
+  const value = localStore.getStore();
+  if (!value) {
+    throw new Error("Store not found.");
+  }
+
+  return value;
+}
+
+export function getStoreOrNull(): Store | null {
+  const value = localStore.getStore();
+  if (!value) {
+    return null;
+  }
+
+  return value;
+}
+
+export function setupStore<User extends StoryBookerUser>(
+  options: RouterOptions<User>,
+  initPromises: Promise<unknown>,
+): MiddlewareHandler {
+  return async (ctx, next) => {
+    const logger = options.logger ?? createConsoleLoggerAdapter();
+
+    startTime(ctx, "init-adapters", "Initialize adapters");
+    await initPromises;
+    endTime(ctx, "init-adapters");
+
+    const request = ctx.req.raw;
+    const headers = new SuperHeaders(request.headers);
+    const locale = headers.acceptLanguage.languages[0] ?? DEFAULT_LOCALE;
+
+    startTime(ctx, "get-user", "Get user details");
+    const user = await options.auth?.getUserDetails({
+      logger,
+      request: request.clone(),
+    });
+    endTime(ctx, "get-user");
+
+    startTime(ctx, "request-handler", "Handle request");
+    localStore.enterWith({
+      ...options,
+      abortSignal: request.signal,
+      auth: options.auth as AuthAdapter | undefined,
+      headers,
+      locale,
+      logger,
+      prefix: options.config?.prefix ?? "",
+      request,
+      url: request.url,
+      user,
+    });
+
+    await next();
+    endTime(ctx, "request-handler");
+  };
+}

package/src/utils/story-utils.ts

@@ -0,0 +1,42 @@
+import type { BuildStoryType } from "../models/builds-schema.ts";
+
+type GroupedStories = Record<string, Record<string, BuildStoryType[]>>;
+
+export function groupStoriesByTitle(stories: BuildStoryType[]): GroupedStories {
+  const groupedStories: GroupedStories = {};
+
+  for (const story of stories) {
+    if (story.type === "docs") {
+      continue;
+    }
+
+    const titleParts = story.title.split("/").map((part) => part.trim());
+
+    if (titleParts.length === 1) {
+      titleParts.unshift("Others");
+    }
+
+    const [groupTitle, ...storyTitleParts] = titleParts;
+    const storyTitle = storyTitleParts.join("/");
+
+    if (!groupTitle) {
+      continue;
+    }
+
+    if (groupedStories[groupTitle]) {
+      const group = groupedStories[groupTitle];
+
+      if (group[storyTitle]) {
+        group[storyTitle].push(story);
+      } else {
+        group[storyTitle] = [story];
+      }
+    } else {
+      groupedStories[groupTitle] = {
+        [storyTitle]: [story],
+      };
+    }
+  }
+
+  return groupedStories;
+}

package/src/utils/text-utils.ts

@@ -0,0 +1,10 @@
+export function toTitleCase(text: string): string {
+  return `${text.slice(0, 1).toUpperCase()}${text.slice(1)}`;
+}
+
+export function camelCaseToSentenceCase(text: string): string {
+  // Insert a space before all uppercase letters
+  const result = text.replaceAll(/([A-Z])/g, " $1");
+  // Lowercase the entire result and capitalize the first letter
+  return result.charAt(0).toUpperCase() + result.slice(1).toLowerCase();
+}

package/src/utils/ui-utils.ts

@@ -0,0 +1,57 @@
+import type { Context } from "hono";
+import type { UIAdapterOptions, UIResult } from "../adapters/_internal/ui.ts";
+import { urlBuilderWithoutStore } from "../urls.ts";
+import { getStore } from "./store.ts";
+
+export function createUIAdapterOptions(): UIAdapterOptions {
+  const { auth, database, storage, ui, locale, logger, url, user } = getStore();
+
+  return {
+    isAuthEnabled: Boolean(auth),
+    locale,
+    logger,
+    url,
+    urlBuilder: urlBuilderWithoutStore,
+    user,
+    adaptersMetadata: {
+      auth: auth?.metadata,
+      database: database?.metadata,
+      logger: logger?.metadata,
+      storage: storage?.metadata,
+      ui: ui?.metadata,
+    },
+  };
+}
+
+// oxlint-disable-next-line max-params
+export function createUIResultResponse<Props>(
+  ctx: Context,
+  render: (props: Props, options: UIAdapterOptions) => UIResult,
+  props: NoInfer<Props>,
+  init?: ResInit,
+): Promise<Response> {
+  return uiResultResponse(ctx, render(props, createUIAdapterOptions()), init);
+}
+
+export async function uiResultResponse(
+  ctx: Context,
+  result: UIResult,
+  init?: ResInit,
+): Promise<Response> {
+  if (result instanceof Promise) {
+    const awaitedResult = await result;
+    if (awaitedResult instanceof Response) {
+      return awaitedResult;
+    }
+
+    return ctx.html(awaitedResult);
+  }
+
+  if (result instanceof Response) {
+    return result;
+  }
+
+  return ctx.html(result, init);
+}
+
+type ResInit = Parameters<Context["html"]>[1];

package/src/utils/url-utils.ts

@@ -0,0 +1,113 @@
+import { hc } from "hono/client";
+import type { AppRouter } from "../routers/_app-router";
+
+type HonoClient = ReturnType<typeof hc<AppRouter>>;
+
+export function linkRoute(
+  link: ((client: HonoClient) => URL) | URL | string,
+  options: { baseUrl?: string; searchParams?: URLSearchParams },
+): string {
+  const { baseUrl, searchParams } = options;
+
+  if (typeof link === "string") {
+    if (baseUrl !== undefined) {
+      return appendSearchParamsToURL(new URL(link, baseUrl), searchParams).toString();
+    }
+    return link;
+  }
+
+  if (link instanceof URL) {
+    return appendSearchParamsToURL(link, searchParams).toString();
+  }
+
+  if (baseUrl) {
+    const client = hc<AppRouter>(baseUrl);
+
+    return appendSearchParamsToURL(link(client), searchParams).toString();
+  }
+
+  const dummyBaseUrl = "http://host.local";
+  const client = hc<AppRouter>(dummyBaseUrl);
+  const url = appendSearchParamsToURL(link(client), searchParams).toString();
+  return url.replace(dummyBaseUrl, "");
+}
+
+function appendSearchParamsToURL(url: URL, searchParams: URLSearchParams | undefined): URL {
+  // oxlint-disable-next-line no-array-for-each
+  searchParams?.forEach((value, key) => {
+    url.searchParams.append(key, value);
+  });
+
+  return url;
+}
+
+export function urlSearchParamsToObject(
+  query: URLSearchParams | FormData,
+): Record<string, unknown> {
+  const result: Record<string, unknown> = {};
+
+  for (const key of query.keys()) {
+    const values = query.getAll(key);
+    // If multiple values for the same key, return array, else single value string
+    result[key] = values.length > 1 ? values : values[0];
+  }
+
+  return result;
+}
+
+export function generatePrefixFromBaseRoute(baseRoute: string): `/${string}` | undefined {
+  if (!baseRoute) {
+    return undefined;
+  }
+  if (baseRoute.startsWith("/")) {
+    return baseRoute as `/${string}`;
+  }
+  return `/${baseRoute}` as const;
+}
+
+export function urlJoin(...parts: string[]): string {
+  if (parts.length === 0) {
+    return "";
+  }
+  let protocol = "";
+  let host = "";
+  // Detect protocol + host in the first argument if present
+  const match = parts[0]?.match(/^([a-zA-Z][a-zA-Z0-9+\-.]*:)?(\/\/[^/?#]*)?/);
+  if (match && (match[1] || match[2])) {
+    protocol = match[1] ?? ""; // e.g. "https:"
+    host = match[2] ?? ""; // e.g. "//example.com"
+    const remainder = parts[0]?.slice((match[0] || "").length);
+    parts = remainder ? [remainder, ...parts.slice(1)] : parts.slice(1);
+  }
+  const segments: string[] = [];
+  for (const part of parts) {
+    for (const seg of part.split("/")) {
+      if (!seg || seg === ".") {
+        continue;
+      }
+      if (seg === "..") {
+        // Don't pop past the beginning
+        if (segments.length > 0) {
+          segments.pop();
+        }
+      } else {
+        segments.push(seg);
+      }
+    }
+  }
+  // Build the final URL
+  let result = "";
+  if (protocol || host) {
+    result = protocol + host;
+    if (segments.length > 0) {
+      // Ensure separator slash between host and path
+      result +=
+        segments[0]?.startsWith("?") || segments[0]?.startsWith("#")
+          ? ""
+          : `/${segments.join("/")}`;
+    }
+  } else {
+    result = `/${segments.join("/")}`;
+  }
+  return result;
+}