@longzai-intelligence-auth/session 0.0.2

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export type { SessionManager } from "./session-manager";
+export { createSessionManager } from "./session-manager";
+export type { CreateSessionDeps, LoginUseCase } from "./use-cases/login";
+export { createLoginUseCase } from "./use-cases/login";
+export type { LogoutUseCase } from "./use-cases/logout";
+export { createLogoutUseCase } from "./use-cases/logout";
+export type { RefreshSessionUseCase } from "./use-cases/refresh-session";
+export { createRefreshSessionUseCase } from "./use-cases/refresh-session";

package/dist/index.js

@@ -0,0 +1,4 @@
+export { createSessionManager } from "./session-manager";
+export { createLoginUseCase } from "./use-cases/login";
+export { createLogoutUseCase } from "./use-cases/logout";
+export { createRefreshSessionUseCase } from "./use-cases/refresh-session";

package/dist/session-manager.d.ts

@@ -0,0 +1,9 @@
+type SessionManager = {
+    generateRefreshToken(): string;
+    hashRefreshToken(token: string): Promise<string>;
+    verifyRefreshToken(token: string, storedHash: string): Promise<boolean>;
+    generateSessionId(): string;
+};
+declare function createSessionManager(): SessionManager;
+export type { SessionManager };
+export { createSessionManager };

package/dist/session-manager.js

@@ -0,0 +1,26 @@
+import { createHash, getRandomValues } from "node:crypto";
+function createSessionManager() {
+    function generateRefreshToken() {
+        const bytes = new Uint8Array(64);
+        getRandomValues(bytes);
+        return Buffer.from(bytes).toString("hex");
+    }
+    function hashRefreshToken(token) {
+        const hash = createHash("sha256").update(token).digest("hex");
+        return Promise.resolve(hash);
+    }
+    async function verifyRefreshToken(token, storedHash) {
+        const hash = await hashRefreshToken(token);
+        return hash === storedHash;
+    }
+    function generateSessionId() {
+        return crypto.randomUUID();
+    }
+    return {
+        generateRefreshToken,
+        hashRefreshToken,
+        verifyRefreshToken,
+        generateSessionId,
+    };
+}
+export { createSessionManager };

package/dist/use-cases/login.d.ts

@@ -0,0 +1,15 @@
+import type { LoginResponse } from "@longzai-intelligence-auth/core";
+import type { AuthBackendPort, TokenSigner } from "@longzai-intelligence-auth/core";
+import type { SessionManager } from "../session-manager";
+type CreateSessionDeps = {
+    adapter: AuthBackendPort;
+    tokenSigner: TokenSigner;
+    sessionManager: SessionManager;
+    defaultTenantId: string;
+};
+type LoginUseCase = {
+    execute(email: string, password: string, deviceInfo?: string, ipAddress?: string): Promise<LoginResponse>;
+};
+declare function createLoginUseCase(deps: CreateSessionDeps): LoginUseCase;
+export type { CreateSessionDeps, LoginUseCase };
+export { createLoginUseCase };

package/dist/use-cases/login.js

@@ -0,0 +1,37 @@
+import { InvalidCredentialsError, AccountDisabledError } from "@longzai-intelligence-auth/core";
+function createLoginUseCase(deps) {
+    const { adapter, tokenSigner, sessionManager, defaultTenantId } = deps;
+    return {
+        async execute(email, password, deviceInfo, ipAddress) {
+            const verifyResult = await adapter.user.verifyPassword(email, password);
+            if (!verifyResult.success || !verifyResult.user) {
+                throw new InvalidCredentialsError();
+            }
+            const user = verifyResult.user;
+            if (user.status !== "active") {
+                throw new AccountDisabledError();
+            }
+            const refreshToken = sessionManager.generateRefreshToken();
+            const refreshTokenHash = await sessionManager.hashRefreshToken(refreshToken);
+            const expiresAt = new Date(Date.now() + 7 * 24 * 60 * 60 * 1000).toISOString();
+            await adapter.session.create({
+                userId: user.id,
+                tenantId: defaultTenantId,
+                refreshTokenHash,
+                deviceInfo,
+                ipAddress,
+                expiresAt,
+            });
+            const accessToken = await tokenSigner.signAccessToken({
+                sub: user.id,
+                type: "access",
+                tenantId: defaultTenantId,
+            });
+            return {
+                accessToken,
+                refreshToken,
+            };
+        },
+    };
+}
+export { createLoginUseCase };

package/dist/use-cases/logout.d.ts

@@ -0,0 +1,14 @@
+import type { MessageResponse } from "@longzai-intelligence-auth/core";
+import type { AuthBackendPort, TokenSigner } from "@longzai-intelligence-auth/core";
+import type { SessionManager } from "../session-manager";
+type CreateSessionDeps = {
+    adapter: AuthBackendPort;
+    tokenSigner: TokenSigner;
+    sessionManager: SessionManager;
+};
+type LogoutUseCase = {
+    execute(sessionId: string): Promise<MessageResponse>;
+};
+declare function createLogoutUseCase(deps: CreateSessionDeps): LogoutUseCase;
+export type { CreateSessionDeps, LogoutUseCase };
+export { createLogoutUseCase };

package/dist/use-cases/logout.js

@@ -0,0 +1,10 @@
+function createLogoutUseCase(deps) {
+    const { adapter } = deps;
+    return {
+        async execute(sessionId) {
+            await adapter.session.revoke(sessionId);
+            return { message: "登出成功" };
+        },
+    };
+}
+export { createLogoutUseCase };

package/dist/use-cases/refresh-session.d.ts

@@ -0,0 +1,14 @@
+import type { RefreshTokenResponse } from "@longzai-intelligence-auth/core";
+import type { AuthBackendPort, TokenSigner } from "@longzai-intelligence-auth/core";
+import type { SessionManager } from "../session-manager";
+type CreateSessionDeps = {
+    adapter: AuthBackendPort;
+    tokenSigner: TokenSigner;
+    sessionManager: SessionManager;
+};
+type RefreshSessionUseCase = {
+    execute(refreshToken: string): Promise<RefreshTokenResponse>;
+};
+declare function createRefreshSessionUseCase(deps: CreateSessionDeps): RefreshSessionUseCase;
+export type { CreateSessionDeps, RefreshSessionUseCase };
+export { createRefreshSessionUseCase };

package/dist/use-cases/refresh-session.js

@@ -0,0 +1,39 @@
+import { SessionNotFoundError, SessionExpiredError } from "@longzai-intelligence-auth/core";
+function createRefreshSessionUseCase(deps) {
+    const { adapter, tokenSigner, sessionManager } = deps;
+    return {
+        async execute(refreshToken) {
+            const refreshTokenHash = await sessionManager.hashRefreshToken(refreshToken);
+            const session = await adapter.session.findByRefreshTokenHash(refreshTokenHash);
+            if (!session) {
+                throw new SessionNotFoundError();
+            }
+            if (new Date(session.expiresAt) < new Date()) {
+                await adapter.session.revoke(session.id);
+                throw new SessionExpiredError();
+            }
+            const newRefreshToken = sessionManager.generateRefreshToken();
+            const newRefreshTokenHash = await sessionManager.hashRefreshToken(newRefreshToken);
+            const newExpiresAt = new Date(Date.now() + 7 * 24 * 60 * 60 * 1000).toISOString();
+            await adapter.session.create({
+                userId: session.userId,
+                tenantId: session.tenantId,
+                refreshTokenHash: newRefreshTokenHash,
+                deviceInfo: session.deviceInfo ?? undefined,
+                ipAddress: session.ipAddress ?? undefined,
+                expiresAt: newExpiresAt,
+            });
+            await adapter.session.revoke(session.id);
+            const accessToken = await tokenSigner.signAccessToken({
+                sub: session.userId,
+                type: "access",
+                tenantId: session.tenantId,
+            });
+            return {
+                accessToken,
+                refreshToken: newRefreshToken,
+            };
+        },
+    };
+}
+export { createRefreshSessionUseCase };

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@longzai-intelligence-auth/session",
+  "version": "0.0.2",
+  "license": "UNLICENSED",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/longzai/longzai-intelligence-auth",
+    "directory": "packages/session"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "bun build src/index.ts --outdir dist --target bun",
+    "build:declaration": "tsgo --declaration --emitDeclarationOnly --outDir dist -p tsconfig/app.json",
+    "build:prod": "NODE_ENV=production tsdown",
+    "prepublishOnly": "bun run build:prod",
+    "typecheck": "bun run typecheck:app && bun run typecheck:node && bun run typecheck:test",
+    "typecheck:app": "tsgo --noEmit -p tsconfig/app.json",
+    "typecheck:node": "tsgo --noEmit -p tsconfig/node.json",
+    "typecheck:test": "tsgo --noEmit -p tsconfig/test.json",
+    "lint": "oxlint && oxfmt --check",
+    "lint:fix": "oxlint --fix && oxfmt",
+    "test": "bun test",
+    "test:watch": "bun test --watch",
+    "test:coverage": "bun test --coverage",
+    "clean": "rm -rf dist out .cache"
+  },
+  "dependencies": {
+    "@longzai-intelligence-auth/core": "0.0.1"
+  }
+}