jax-hono 1.0.26 → 1.0.28

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jax-hono",
-  "version": "1.0.26",
+  "version": "1.0.28",
   "description": "Lightweight framework layer on top of Hono, built for Bun",
   "type": "module",
   "main": "./index.ts",
@@ -101,6 +101,7 @@
     "axios": "^1.18.1",
     "@types/bun": "^1.3.14",
     "@types/jsonwebtoken": "^9.0.10",
+    "@types/minimist": "^1.2.5",
     "dayjs": "^1.11.21",
     "deepmerge": "^4.3.1",
     "dotenv": "^17.4.2",

package/utils/error.ts

@@ -0,0 +1,5 @@
+export function getErrorMessage(error: unknown): string {
+  if (error instanceof Error) return error.message;
+  if (error == null) return String(error);
+  return typeof error === "string" ? error : String(error);
+}

package/utils/index.ts

@@ -1,8 +1,10 @@
 export * from "./array";
 export * from "./async";
-export * from "./crypto";
-export * from "./http";
-export * from "./order";
-export * from "./regexp";
-export * from "./transform";
-export * from "./validate";
+export * from "./crypto";
+export * from "./error";
+export * from "./http";
+export * from "./order";
+export * from "./regexp";
+export * from "./transform";
+export * from "./upload";
+export * from "./validate";

package/utils/upload.ts

@@ -0,0 +1,194 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { extname, join } from "node:path";
+
+export type SaveUploadFileOptions = {
+  dir?: string;
+  filename?: string;
+  uploadDir?: string;
+  urlPrefix?: string;
+  serverUrl?: string;
+};
+
+export type SaveUploadFileResult = {
+  url: string;
+  originalName: string;
+  mimeType: string;
+};
+
+export type SaveBase64ImageOptions = {
+  dir?: string;
+  filename?: string;
+  uploadDir?: string;
+  urlPrefix?: string;
+  serverUrl?: string;
+};
+
+type ParsedBase64Image = {
+  ext: string;
+  base64: string;
+};
+
+type UploadConfig = {
+  uploadDir?: string;
+  serverUrl?: string;
+};
+
+let runtimeConfig: UploadConfig | undefined;
+
+export async function saveUploadFile(
+  file: File,
+  options: SaveUploadFileOptions = {},
+): Promise<SaveUploadFileResult> {
+  const ext = extname(file.name) || extByMimeType(file.type);
+  const filename = options.filename || getUploadFilename(ext);
+  const dir = options.dir || "open";
+  const datePath = todayPath();
+  const saveDir = join(
+    getUploadDir(options),
+    ...getRelativeParts(dir, datePath),
+  );
+  const filePath = join(saveDir, filename);
+
+  await mkdir(saveDir, { recursive: true });
+  await Bun.write(filePath, file);
+
+  return {
+    url: getUploadUrl({ ...options, dir, datePath, filename }),
+    originalName: file.name,
+    mimeType: file.type,
+  };
+}
+
+export async function saveBase64Image(
+  value: string,
+  dirOrOptions: string | SaveBase64ImageOptions = "",
+): Promise<string> {
+  const options =
+    typeof dirOrOptions === "string" ? { dir: dirOrOptions } : dirOrOptions;
+  const image = parseBase64Image(value);
+  const filename = options.filename || getUploadFilename(image.ext);
+  const datePath = todayPath();
+  const saveDir = join(
+    getUploadDir(options),
+    ...getRelativeParts(options.dir, datePath),
+  );
+  const filePath = join(saveDir, filename);
+
+  await mkdir(saveDir, { recursive: true });
+  await writeFile(filePath, Buffer.from(image.base64, "base64"));
+
+  return getUploadUrl({ ...options, datePath, filename });
+}
+
+export function isBase64Image(value: string) {
+  return /^data:image\/[a-zA-Z0-9+.-]+;base64,/.test(value);
+}
+
+export function isUploadedUrl(value: string, urlPrefix = "/uploads") {
+  return /^(https?:)?\/\//.test(value) || value.startsWith(`${urlPrefix}/`);
+}
+
+export function getUploadFilename(ext: string) {
+  const random = Math.random().toString().slice(2, 7).padEnd(5, "0");
+  const now = new Date();
+  const time = [
+    now.getHours().toString().padStart(2, "0"),
+    now.getMinutes().toString().padStart(2, "0"),
+    now.getSeconds().toString().padStart(2, "0"),
+  ].join("");
+
+  return `${time}${random}${ext}`;
+}
+
+function parseBase64Image(value: string): ParsedBase64Image {
+  const match = value.match(/^data:image\/([a-zA-Z0-9+.-]+);base64,(.*)$/);
+
+  if (!match) {
+    throw new Error("Invalid image format");
+  }
+
+  return {
+    ext: extByMimeType(`image/${match[1]}`),
+    base64: match[2],
+  };
+}
+
+function getUploadDir(options: SaveUploadFileOptions | SaveBase64ImageOptions) {
+  return String(
+    options.uploadDir ||
+      getRuntimeConfig().uploadDir ||
+      join(process.cwd(), "storage/public"),
+  );
+}
+
+function getUploadUrl(
+  options: (SaveUploadFileOptions | SaveBase64ImageOptions) & {
+    datePath: string;
+    filename: string;
+  },
+) {
+  const serverUrl = options.serverUrl ?? getRuntimeConfig().serverUrl ?? "";
+  const urlPrefix = options.urlPrefix || "/uploads";
+  const path = joinUrlPath(
+    urlPrefix,
+    options.dir,
+    options.datePath,
+    options.filename,
+  );
+
+  return `${serverUrl}${path}`;
+}
+
+function getRuntimeConfig() {
+  runtimeConfig ??= (require("../config") as { default: UploadConfig }).default;
+
+  return runtimeConfig;
+}
+
+function todayPath() {
+  const now = new Date();
+  const year = now.getFullYear().toString().slice(-2);
+  const month = (now.getMonth() + 1).toString().padStart(2, "0");
+  const day = now.getDate().toString().padStart(2, "0");
+
+  return `${year}${month}${day}`;
+}
+
+function getRelativeParts(...values: Array<string | undefined>) {
+  return values
+    .flatMap((value) => (value || "").split(/[\\/]+/))
+    .filter(Boolean)
+    .map((part) => {
+      if (part === "." || part === "..") {
+        throw new Error("Upload dir cannot contain relative path segments");
+      }
+
+      return part;
+    });
+}
+
+function joinUrlPath(...values: Array<string | undefined>) {
+  const [first = "", ...rest] = values;
+  const prefix = first.startsWith("/") ? "/" : "";
+  const parts = [
+    first.replace(/^\/+|\/+$/g, ""),
+    ...rest.map((value) => (value || "").replace(/^\/+|\/+$/g, "")),
+  ].filter(Boolean);
+
+  return `${prefix}${parts.join("/")}`;
+}
+
+function extByMimeType(mimeType: string) {
+  return (
+    (
+      {
+        "image/jpeg": ".jpg",
+        "image/jpg": ".jpg",
+        "image/png": ".png",
+        "image/gif": ".gif",
+        "image/webp": ".webp",
+        "image/svg+xml": ".svg",
+      } as Record<string, string>
+    )[mimeType] || ".jpg"
+  );
+}