jax-hono 1.0.2 → 1.0.3

package/index.ts

@@ -1,4 +1,6 @@
 import { Hono } from 'hono';
+import './core/hono';
+import './middleware/api-response';
 import { createHono, createApi } from './core/hono';
 import { registerCrudRoutes } from './helpers/crud';
 import type { Config } from './config';

package/middleware/jwt.ts

@@ -1,62 +1,67 @@
-import config from '../config';
-import jwt from 'jsonwebtoken';
-import type { Context, MiddlewareHandler, Next } from 'hono';
+import config from "../config";
+import jwt from "jsonwebtoken";
+import type { Context, MiddlewareHandler, Next } from "hono";
 
-type JwtAuthOptions<TPayload extends Record<string, any> = Record<string, any>> = {
+type JwtAuthOptions<
+  TPayload extends Record<string, any> = Record<string, any>,
+> = {
   secretSuffix: string;
   stateKey: string;
   validate?: (payload: TPayload, c: Context) => boolean | Promise<boolean>;
   resolveState?: (payload: TPayload, c: Context) => unknown | Promise<unknown>;
 };
 
-function createJwtAuth<TPayload extends Record<string, any> = Record<string, any>>(
-  options: JwtAuthOptions<TPayload>
-): MiddlewareHandler {
+function createJwtAuth<
+  TPayload extends Record<string, any> = Record<string, any>,
+>(options: JwtAuthOptions<TPayload>): MiddlewareHandler {
   return async (c, next) => {
-    const session = c.get('session');
-    const sessionData = session.get(options.stateKey);
+    // const session = c.get('session');
+    // const sessionData = session.get(options.stateKey);
 
-    if (sessionData) {
-      console.log('sessionData', sessionData);
-      c.state[options.stateKey] = sessionData;
-      await next();
-    }
+    // if (sessionData) {
+    //   c.state[options.stateKey] = sessionData;
+    //   await next();
+    // }
 
     const token = getAuthorizationToken(c);
 
     if (!token) {
-      return c.json({ code: 401, msg: '请先登录' });
+      return c.json({ code: 401, msg: "请先登录" });
     }
 
     try {
       const payload = jwt.verify(
         token,
-        (config as any).jwt.secret + options.secretSuffix
+        (config as any).jwt.secret + options.secretSuffix,
       ) as TPayload;
-      const valid = options.validate ? await options.validate(payload, c) : true;
+      const valid = options.validate
+        ? await options.validate(payload, c)
+        : true;
 
       if (!valid) {
-        return c.json({ code: 401, msg: '请重新登录' });
+        return c.json({ code: 401, msg: "请重新登录" });
       }
 
-      const stateValue = options.resolveState ? await options.resolveState(payload, c) : payload;
+      const stateValue = options.resolveState
+        ? await options.resolveState(payload, c)
+        : payload;
 
       if (!stateValue) {
-        return c.json({ code: 401, msg: '请重新登录' });
+        return c.json({ code: 401, msg: "请重新登录" });
       }
 
       c.state[options.stateKey] = stateValue;
 
       await next();
     } catch {
-      return c.json({ code: 401, msg: '请重新登录' });
+      return c.json({ code: 401, msg: "请重新登录" });
     }
   };
 }
 
 function createOptionalAuth(auth: MiddlewareHandler): MiddlewareHandler {
   return async (c, next) => {
-    if (!c.req.header('authorization')) {
+    if (!c.req.header("authorization")) {
       await next();
       return;
     }
@@ -66,10 +71,10 @@ function createOptionalAuth(auth: MiddlewareHandler): MiddlewareHandler {
 }
 
 function getAuthorizationToken(c: Context) {
-  const authorization = c.req.header('authorization') ?? '';
+  const authorization = c.req.header("authorization") ?? "";
 
-  return authorization.startsWith('Bearer ')
-    ? authorization.slice('Bearer '.length)
+  return authorization.startsWith("Bearer ")
+    ? authorization.slice("Bearer ".length)
     : authorization;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jax-hono",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "Lightweight framework layer on top of Hono, built for Bun",
   "type": "module",
   "main": "./index.ts",
@@ -82,10 +82,10 @@
   },
   "dependencies": {
     "@hono/session": "^0.2.1",
-    "cac": "^7.0.0",
-    "hono": "^4.12.27"
+    "cac": "^7.0.0"
   },
   "peerDependencies": {
+    "hono": "^4.12.27",
     "dayjs": "*",
     "deepmerge": "^4.3.1",
     "dotenv": "^17.4.2",
@@ -98,6 +98,7 @@
     "dayjs": "^1.11.21",
     "deepmerge": "^4.3.1",
     "dotenv": "^17.4.2",
+    "hono": "^4.12.27",
     "jsonwebtoken": "^9.0.3",
     "minimist": "^1.2.8",
     "mongoose": "^8.24.1"
@@ -117,4 +118,4 @@
     "bun": ">=1.0.0"
   },
   "license": "MIT"
-}
+}

package/plugins/session/index.ts

@@ -1,20 +1,86 @@
-import { useSession, useSessionStorage } from '@hono/session'
-import type { SessionEnv } from '@hono/session'
-import { Hono } from 'hono'
-import { definePlugin } from '../define'
+import { useSession, useSessionStorage } from '@hono/session';
+import type { Session, SessionData, SessionOptions, Storage } from '@hono/session';
+import type { Context } from 'hono';
+import { definePlugin } from '../define';
+
+export type JaxSessionData = SessionData;
+
+export type SessionStorageFactory<Data extends SessionData = JaxSessionData> = (
+  c: Context
+) => Storage<Data>;
+
+export type SessionPluginOptions<Data extends SessionData = JaxSessionData> =
+  SessionOptions<Data> & {
+    /**
+     * Optional backing storage. When omitted, @hono/session keeps session data
+     * inside the encrypted cookie.
+     */
+    storage?: Storage<Data> | SessionStorageFactory<Data>;
+  };
+
+declare module 'hono' {
+  interface ContextVariableMap {
+    session: Session<JaxSessionData>;
+    sessionStorage?: Storage<JaxSessionData>;
+  }
+}
+
+const DEFAULT_SESSION_DURATION = {
+  // 会话的有效时间以秒为单位。超过该时间后，会话将失效，需要重新认证才能继续使用。
+  absolute: 60 * 60 * 24 * 7 // 7天
+};
+
+const DEFAULT_SESSION_OPTIONS: SessionPluginOptions = {
+  secret: 'jax-session',
+  duration: DEFAULT_SESSION_DURATION
+};
+
+function isSessionPluginOptions(options: unknown): options is SessionPluginOptions {
+  return Boolean(options && typeof options === 'object' && !Array.isArray(options));
+}
+
+function resolveSessionOptions(config: unknown, options: unknown): SessionPluginOptions {
+  const configOptions = readConfigSessionOptions(config);
+  const pluginOptions = isSessionPluginOptions(options) ? options : {};
+  const duration: NonNullable<SessionPluginOptions['duration']> = {
+    absolute: DEFAULT_SESSION_DURATION.absolute,
+    ...configOptions.duration,
+    ...pluginOptions.duration
+  };
+  const { storage, ...sessionOptions } = {
+    ...DEFAULT_SESSION_OPTIONS,
+    ...configOptions,
+    ...pluginOptions,
+    duration
+  };
+
+  return {
+    ...sessionOptions,
+    storage
+  };
+}
+
+function readConfigSessionOptions(config: unknown): SessionPluginOptions {
+  if (!config || typeof config !== 'object' || Array.isArray(config)) {
+    return {};
+  }
+
+  const session = (config as { session?: unknown }).session;
+
+  return isSessionPluginOptions(session) ? session : {};
+}
 
 export default definePlugin({
-  setup(ctx) {
-    ctx.app.use(
-      useSession({
-        secret: ctx.config?.session?.secret || 'jax-session',
-        duration: {
-          // 会话的有效时间以秒为单位。超过该时间后，会话将失效，需要重新认证才能继续使用。
-          absolute: 60 * 60 * 24 * 7, // 7天
-          // 会话被视为活跃的时间长度，以秒为单位。在这一时间内，会话的最大年龄可以延长。
-          // inactivity: 60 * 5,
-        },
-      }),
-    )
-  },
-})
+  setup(ctx, options) {
+    const { storage, ...sessionOptions } = resolveSessionOptions(ctx.config, options);
+
+    if (storage) {
+      ctx.app.use(useSessionStorage(storage));
+    }
+
+    ctx.app.use(useSession(sessionOptions));
+  }
+});
+
+export type { Session, SessionData, SessionOptions, Storage };
+export { useSession, useSessionStorage };

package/types/config.ts

@@ -1,13 +1,9 @@
+import type { SessionPluginOptions } from '../plugins/session';
+
 export type JaxConfig = {
   rootDir: string;
   port: number;
   env: string;
 
-  session?: {
-    secret?: string;
-    duration?: {
-      absolute: number;
-      inactivity?: number;
-    };
-  };
+  session?: SessionPluginOptions;
 };