@dangao/bun-server 1.0.0 → 1.0.3

package/src/session/middleware.ts

@@ -0,0 +1,143 @@
+import type { Context } from '../core/context';
+import type { Middleware, NextFunction } from '../middleware/middleware';
+import { SessionService } from './service';
+import { SESSION_SERVICE_TOKEN } from './types';
+import type { Container } from '../di/container';
+
+/**
+ * Session 中间件
+ * 从 Cookie 中读取 Session ID，并将 Session 对象附加到 Context
+ */
+export function createSessionMiddleware(
+  container: Container,
+): Middleware {
+  return async (context: Context, next: NextFunction): Promise<Response> => {
+    let sessionService: SessionService | undefined;
+    try {
+      sessionService = container.resolve<SessionService>(
+        SESSION_SERVICE_TOKEN,
+      );
+    } catch {
+      // 如果 SessionService 未注册，跳过 Session 处理
+      return await next();
+    }
+
+    if (!sessionService) {
+      return await next();
+    }
+
+    // 从 Cookie 中读取 Session ID
+    const cookieName = sessionService.getCookieName();
+    const cookieHeader = context.request.headers.get('cookie');
+    let sessionId: string | undefined;
+
+    if (cookieHeader) {
+      // Cookie 格式: "name=value; name2=value2" 或 "name=value"
+      // 需要正确处理多个 Cookie 的情况
+      const cookies = cookieHeader.split(';').map((c) => c.trim());
+      for (const cookie of cookies) {
+        if (cookie.startsWith(`${cookieName}=`)) {
+          sessionId = cookie.substring(cookieName.length + 1).trim();
+          break;
+        }
+      }
+    }
+
+    // 如果有 Session ID，获取 Session
+    if (sessionId) {
+      const session = await sessionService.get(sessionId);
+      if (session) {
+        // 将 Session 附加到 Context
+        (context as unknown as { session: typeof session }).session = session;
+        (context as unknown as { sessionId: string }).sessionId = sessionId;
+      } else {
+        // Session 已过期或不存在，清除 sessionId
+        sessionId = undefined;
+      }
+    }
+
+    // 如果没有 Session，创建一个新 Session
+    if (!sessionId) {
+      const newSession = await sessionService.create();
+      (context as unknown as { session: typeof newSession }).session =
+        newSession;
+      (context as unknown as { sessionId: string }).sessionId = newSession.id;
+      sessionId = newSession.id;
+    }
+
+    // 调用下一个中间件
+    const response = await next();
+
+    // 设置或更新 Cookie
+    const currentSessionId = (context as unknown as { sessionId?: string })
+      .sessionId;
+    if (currentSessionId) {
+      const cookieOptions = sessionService.getCookieOptions();
+      const maxAge = sessionService.getMaxAge();
+      const cookieValue = buildCookie(
+        cookieName,
+        currentSessionId,
+        {
+          ...cookieOptions,
+          maxAge,
+        },
+      );
+      
+      // 创建新的 Response，添加 Set-Cookie 头
+      const newHeaders = new Headers(response.headers);
+      newHeaders.set('Set-Cookie', cookieValue);
+      
+      return new Response(response.body, {
+        status: response.status,
+        statusText: response.statusText,
+        headers: newHeaders,
+      });
+    }
+
+    return response;
+  };
+}
+
+/**
+ * 构建 Cookie 字符串
+ */
+function buildCookie(
+  name: string,
+  value: string,
+  options: {
+    secure?: boolean;
+    httpOnly?: boolean;
+    path?: string;
+    domain?: string;
+    sameSite?: 'strict' | 'lax' | 'none';
+    maxAge?: number;
+  },
+): string {
+  let cookie = `${name}=${value}`;
+
+  if (options.path) {
+    cookie += `; Path=${options.path}`;
+  }
+
+  if (options.domain) {
+    cookie += `; Domain=${options.domain}`;
+  }
+
+  if (options.maxAge) {
+    cookie += `; Max-Age=${Math.floor(options.maxAge / 1000)}`;
+  }
+
+  if (options.secure) {
+    cookie += '; Secure';
+  }
+
+  if (options.httpOnly) {
+    cookie += '; HttpOnly';
+  }
+
+  if (options.sameSite) {
+    cookie += `; SameSite=${options.sameSite}`;
+  }
+
+  return cookie;
+}

package/src/session/service.ts

@@ -0,0 +1,218 @@
+import { Injectable } from '../di/decorators';
+import { Inject } from '../di/decorators';
+import type {
+  SessionStore,
+  SessionModuleOptions,
+  Session,
+  SessionData,
+} from './types';
+import { SESSION_OPTIONS_TOKEN } from './types';
+import { randomBytes } from 'crypto';
+
+/**
+ * Session 服务
+ */
+@Injectable()
+export class SessionService {
+  private store: SessionStore;
+  private name: string;
+  private maxAge: number;
+  private rolling: boolean;
+  private cookieOptions: Required<SessionModuleOptions>['cookie'];
+
+  public constructor(
+    @Inject(SESSION_OPTIONS_TOKEN) options: SessionModuleOptions,
+  ) {
+    this.store = options.store!;
+    this.name = options.name ?? 'sessionId';
+    this.maxAge = options.maxAge ?? 86400000; // 24 小时
+    this.rolling = options.rolling ?? true;
+    this.cookieOptions = {
+      secure: options.cookie?.secure ?? false,
+      httpOnly: options.cookie?.httpOnly ?? true,
+      path: options.cookie?.path ?? '/',
+      domain: options.cookie?.domain,
+      sameSite: options.cookie?.sameSite ?? 'lax',
+    };
+  }
+
+  /**
+   * 生成 Session ID
+   * @returns Session ID
+   */
+  private generateSessionId(): string {
+    return randomBytes(32).toString('hex');
+  }
+
+  /**
+   * 创建新 Session
+   * @param initialData - 初始数据
+   * @returns Session
+   */
+  public async create(initialData: SessionData = {}): Promise<Session> {
+    const now = Date.now();
+    const session: Session = {
+      id: this.generateSessionId(),
+      data: initialData,
+      createdAt: now,
+      lastAccessedAt: now,
+      expiresAt: now + this.maxAge,
+    };
+
+    await this.store.set(session, this.maxAge);
+    return session;
+  }
+
+  /**
+   * 获取 Session
+   * @param sessionId - Session ID
+   * @returns Session，如果不存在或已过期则返回 undefined
+   */
+  public async get(sessionId: string): Promise<Session | undefined> {
+    const session = await this.store.get(sessionId);
+    if (!session) {
+      return undefined;
+    }
+
+    // 如果启用了 rolling，更新最后访问时间和过期时间
+    if (this.rolling) {
+      await this.touch(sessionId);
+    }
+
+    return session;
+  }
+
+  /**
+   * 更新 Session 数据
+   * @param sessionId - Session ID
+   * @param data - 新数据
+   * @returns 是否更新成功
+   */
+  public async set(
+    sessionId: string,
+    data: SessionData,
+  ): Promise<boolean> {
+    const session = await this.store.get(sessionId);
+    if (!session) {
+      return false;
+    }
+
+    session.data = { ...session.data, ...data };
+    session.lastAccessedAt = Date.now();
+
+    if (this.rolling) {
+      session.expiresAt = Date.now() + this.maxAge;
+    }
+
+    return this.store.set(session, this.maxAge);
+  }
+
+  /**
+   * 获取 Session 数据中的某个值
+   * @param sessionId - Session ID
+   * @param key - 数据键
+   * @returns 数据值，如果不存在则返回 undefined
+   */
+  public async getValue<T = unknown>(
+    sessionId: string,
+    key: string,
+  ): Promise<T | undefined> {
+    const session = await this.store.get(sessionId);
+    if (!session) {
+      return undefined;
+    }
+
+    return session.data[key] as T | undefined;
+  }
+
+  /**
+   * 设置 Session 数据中的某个值
+   * @param sessionId - Session ID
+   * @param key - 数据键
+   * @param value - 数据值
+   * @returns 是否设置成功
+   */
+  public async setValue<T = unknown>(
+    sessionId: string,
+    key: string,
+    value: T,
+  ): Promise<boolean> {
+    const session = await this.store.get(sessionId);
+    if (!session) {
+      return false;
+    }
+
+    session.data[key] = value;
+    session.lastAccessedAt = Date.now();
+
+    if (this.rolling) {
+      session.expiresAt = Date.now() + this.maxAge;
+    }
+
+    return this.store.set(session, this.maxAge);
+  }
+
+  /**
+   * 删除 Session 数据中的某个值
+   * @param sessionId - Session ID
+   * @param key - 数据键
+   * @returns 是否删除成功
+   */
+  public async deleteValue(sessionId: string, key: string): Promise<boolean> {
+    const session = await this.store.get(sessionId);
+    if (!session) {
+      return false;
+    }
+
+    delete session.data[key];
+    session.lastAccessedAt = Date.now();
+
+    if (this.rolling) {
+      session.expiresAt = Date.now() + this.maxAge;
+    }
+
+    return this.store.set(session, this.maxAge);
+  }
+
+  /**
+   * 删除 Session
+   * @param sessionId - Session ID
+   * @returns 是否删除成功
+   */
+  public async delete(sessionId: string): Promise<boolean> {
+    return this.store.delete(sessionId);
+  }
+
+  /**
+   * 更新 Session 的最后访问时间
+   * @param sessionId - Session ID
+   * @returns 是否更新成功
+   */
+  public async touch(sessionId: string): Promise<boolean> {
+    return this.store.touch(sessionId);
+  }
+
+  /**
+   * 获取 Cookie 名称
+   * @returns Cookie 名称
+   */
+  public getCookieName(): string {
+    return this.name;
+  }
+
+  /**
+   * 获取 Cookie 选项
+   * @returns Cookie 选项
+   */
+  public getCookieOptions(): Required<SessionModuleOptions>['cookie'] {
+    return this.cookieOptions;
+  }
+
+  /**
+   * 获取最大存活时间
+   * @returns 最大存活时间（毫秒）
+   */
+  public getMaxAge(): number {
+    return this.maxAge;
+  }
+}

package/src/session/session-module.ts

@@ -0,0 +1,69 @@
+import { Module, MODULE_METADATA_KEY, type ModuleProvider } from '../di/module';
+
+import { SessionService } from './service';
+import {
+  SESSION_OPTIONS_TOKEN,
+  SESSION_SERVICE_TOKEN,
+  MemorySessionStore,
+  type SessionModuleOptions,
+  type SessionStore,
+} from './types';
+
+@Module({
+  providers: [],
+})
+export class SessionModule {
+  /**
+   * 创建 Session 模块
+   * @param options - 模块配置
+   */
+  public static forRoot(
+    options: SessionModuleOptions = {},
+  ): typeof SessionModule {
+    const providers: ModuleProvider[] = [];
+
+    // 如果没有提供 store，使用默认的内存存储
+    const store: SessionStore =
+      options.store ??
+      new MemorySessionStore({
+        cleanupInterval: 60000, // 每分钟清理一次
+      });
+
+    const service = new SessionService({
+      store,
+      name: options.name,
+      maxAge: options.maxAge,
+      rolling: options.rolling,
+      cookie: options.cookie,
+    });
+
+    providers.push(
+      {
+        provide: SESSION_SERVICE_TOKEN,
+        useValue: service,
+      },
+      {
+        provide: SESSION_OPTIONS_TOKEN,
+        useValue: options,
+      },
+      SessionService,
+    );
+
+    // 动态更新模块元数据
+    const existingMetadata =
+      Reflect.getMetadata(MODULE_METADATA_KEY, SessionModule) || {};
+    const metadata = {
+      ...existingMetadata,
+      providers: [...(existingMetadata.providers || []), ...providers],
+      exports: [
+        ...(existingMetadata.exports || []),
+        SESSION_SERVICE_TOKEN,
+        SESSION_OPTIONS_TOKEN,
+        SessionService,
+      ],
+    };
+    Reflect.defineMetadata(MODULE_METADATA_KEY, metadata, SessionModule);
+
+    return SessionModule;
+  }
+}