storybooker 0.19.4 → 0.22.0-canary.0

package/src/utils/error.ts

@@ -0,0 +1,140 @@
+import type { ErrorHandler, MiddlewareHandler } from "hono";
+import { HTTPException } from "hono/http-exception";
+import type { ServerErrorStatusCode } from "hono/utils/http-status";
+import { z } from "zod";
+import { createConsoleLoggerAdapter, type LoggerAdapter } from "../adapters/_internal/index.ts";
+import type { RouterOptions, StoryBookerUser } from "../types.ts";
+import { getStoreOrNull } from "../utils/store.ts";
+import { DEFAULT_LOCALE } from "./constants.ts";
+import { checkIsHTMLRequest } from "./request.ts";
+import { uiResultResponse } from "./ui-utils.ts";
+
+/**
+ * A function type for parsing custom errors.
+ * Return `undefined` from parser if the service should handle the error.
+ */
+export type ErrorParser = (error: unknown) => ParsedError | undefined;
+/** Parsed error information. */
+export interface ParsedError {
+  errorMessage: string;
+  errorStatus?: number;
+  errorType: string;
+}
+
+export function parseErrorMessage(error: unknown, errorParser?: ErrorParser): ParsedError {
+  if (!error) {
+    return { errorMessage: "", errorType: "unknown" };
+  }
+
+  const customErrorParser = errorParser ?? getStoreOrNull()?.errorParser;
+  const customErrorResult = customErrorParser?.(error);
+  if (customErrorResult !== undefined) {
+    return customErrorResult;
+  }
+
+  if (typeof error === "string") {
+    return { errorMessage: error, errorType: "string" };
+  }
+
+  if (error instanceof HTTPException) {
+    const { message, status } = unwrapHttpException(error);
+    return {
+      errorMessage: message,
+      errorStatus: status,
+      errorType: "HTTPException",
+    };
+  }
+
+  if (error instanceof z.core.$ZodError) {
+    return {
+      errorMessage: z.prettifyError(error),
+      errorStatus: 400,
+      errorType: "Zod",
+    };
+  }
+
+  if (error instanceof Error || (error && typeof error === "object" && "message" in error)) {
+    return { errorMessage: String(error.message), errorType: "error" };
+  }
+
+  return { errorMessage: String(error), errorType: "unknown" };
+}
+
+const zodValidationErrorSchema = z.object({
+  success: z.literal(false),
+  error: z.object({
+    name: z.literal("ZodError"),
+    message: z.string(),
+  }),
+});
+export function prettifyZodValidationErrorMiddleware(logger: LoggerAdapter): MiddlewareHandler {
+  return async (ctx, next) => {
+    await next();
+
+    const resContentType = ctx.res.headers.get("Content-Type") ?? "";
+    if (ctx.res.status === 400 && resContentType.startsWith("application/json")) {
+      const result = zodValidationErrorSchema.safeParse(await ctx.res.clone().json());
+      if (result.success) {
+        const issues = JSON.parse(result.data.error.message) as z.core.$ZodIssue[];
+        const message = `Validation error:\n${z.prettifyError({ issues })}`;
+        logger.error(`[Zod] ${message}`);
+        throw new HTTPException(400, { message, res: ctx.res });
+      }
+    }
+  };
+}
+
+export function onUnhandledErrorHandler<User extends StoryBookerUser>(
+  options: RouterOptions<User>,
+): ErrorHandler {
+  return (error, ctx) => {
+    if (error instanceof Response) {
+      return error;
+    }
+    const logger = options.logger ?? createConsoleLoggerAdapter();
+
+    const parsedError = parseErrorMessage(error);
+    const { errorMessage, errorStatus, errorType } = parsedError;
+    logger.error(`[${errorType}:${errorStatus}] ${errorMessage}`);
+
+    if (options?.ui?.renderErrorPage && checkIsHTMLRequest(false, ctx.req.raw)) {
+      const result = options.ui.renderErrorPage(parsedError, {
+        isAuthEnabled: Boolean(options.auth),
+        locale: DEFAULT_LOCALE,
+        logger,
+        url: ctx.req.url,
+        user: null,
+        adaptersMetadata: {},
+      });
+
+      return uiResultResponse(ctx, result, {
+        status: (errorStatus as ServerErrorStatusCode) ?? 500,
+      });
+    }
+
+    return new Response(errorMessage, { status: errorStatus ?? 500, statusText: errorType });
+  };
+}
+
+function unwrapHttpException(error: HTTPException): {
+  message: string;
+  status?: number;
+} {
+  let causeMessage = "";
+  let causeStatus: number | undefined = error.status;
+
+  if (error.cause) {
+    if (error.cause instanceof HTTPException) {
+      const { message, status } = unwrapHttpException(error.cause);
+      causeMessage = message;
+      causeStatus = status;
+    } else {
+      const { errorMessage } = parseErrorMessage(error.cause);
+      causeMessage = errorMessage;
+    }
+  }
+
+  const errorStatus = causeStatus ?? error.status;
+  const errorMessage = causeMessage ? `${error.message}\n ↳ ${causeMessage}` : error.message;
+  return { message: errorMessage, status: errorStatus };
+}

package/src/utils/file-utils.test.ts

@@ -0,0 +1,65 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { Readable } from "node:stream";
+import { describe, expect, it } from "vitest";
+import { writeStreamToFile, writeWebStreamToFile } from "./file-utils.ts";
+
+describe("writeStreamToFile", () => {
+  it("should work with node-readable", async () => {
+    const dirpath = fs.mkdtempSync(path.join(os.tmpdir(), "file-utils-test"));
+    const filepath = path.join(dirpath, "output.txt");
+
+    const data = ["hello", "world"];
+    const readable = Readable.from(data);
+    await writeStreamToFile(filepath, readable);
+
+    const fileContent = fs.readFileSync(filepath, "utf8");
+    expect(fileContent).toBe(data.join(""));
+    fs.rmSync(dirpath, { recursive: true, force: true });
+  });
+
+  it("should work with web-readable", async () => {
+    const dirpath = fs.mkdtempSync(path.join(os.tmpdir(), "file-utils-test"));
+    const filepath = path.join(dirpath, "output.txt");
+
+    const data = ["hello", "world"];
+
+    const readable = readableStreamFromArray(data);
+    await writeStreamToFile(filepath, readable);
+
+    const fileContent = fs.readFileSync(filepath, "utf8");
+    expect(fileContent).toBe(data.join(""));
+    fs.rmSync(dirpath, { recursive: true, force: true });
+  });
+});
+
+describe("writeWebStreamToFile", () => {
+  it("should work", async () => {
+    const dirpath = fs.mkdtempSync(path.join(os.tmpdir(), "file-utils-test"));
+    const filepath = path.join(dirpath, "output.txt");
+
+    const data = ["hello", "world"];
+
+    const readable = readableStreamFromArray(data);
+    await writeWebStreamToFile(readable, filepath);
+
+    const fileContent = fs.readFileSync(filepath, "utf8");
+    expect(fileContent).toBe(data.join(""));
+    fs.rmSync(dirpath, { recursive: true, force: true });
+  });
+});
+
+function readableStreamFromArray<Type>(arr: Type[]): ReadableStream<Type> {
+  let index = 0;
+  return new ReadableStream({
+    pull(controller) {
+      if (index < arr.length) {
+        controller.enqueue(arr[index]);
+        index += 1;
+      } else {
+        controller.close();
+      }
+    },
+  });
+}

package/src/utils/file-utils.ts

@@ -0,0 +1,43 @@
+import { once } from "node:events";
+import { createWriteStream } from "node:fs";
+import { Readable } from "node:stream";
+import type { ReadableStream as WebReadableStream } from "node:stream/web";
+
+export async function writeStreamToFile(
+  filePath: string,
+  stream: Readable | ReadableStream,
+): Promise<void> {
+  const writable = createWriteStream(filePath);
+  const readable =
+    stream instanceof Readable ? stream : Readable.fromWeb(stream as WebReadableStream);
+  for await (const chunk of readable) {
+    if (!writable.write(chunk)) {
+      // Wait if backpressure is applied
+      await once(writable, "drain");
+    }
+  }
+  writable.end();
+  await once(writable, "finish");
+}
+
+export function writeWebStreamToFile(
+  webReadableStream: ReadableStream,
+  outputPath: string,
+): Promise<null> {
+  // Convert WebReadableStream to Node.js Readable stream
+  const nodeReadableStream = Readable.fromWeb(webReadableStream as WebReadableStream);
+
+  // Create a writable file stream
+  const fileWritableStream = createWriteStream(outputPath);
+
+  // Pipe the Node.js readable stream to the writable file stream
+  nodeReadableStream.pipe(fileWritableStream);
+
+  // Return a promise that resolves when writing is finished
+  return new Promise((resolve, reject) => {
+    fileWritableStream.on("finish", () => {
+      resolve(null);
+    });
+    fileWritableStream.on("error", reject);
+  });
+}

package/src/utils/index.ts

@@ -0,0 +1,3 @@
+export * from "./constants.ts";
+export { parseErrorMessage, type ErrorParser, type ParsedError } from "./error.ts";
+export { generatePrefixFromBaseRoute, urlJoin } from "./url-utils.ts";