@longzai-intelligence-auth/sdk 0.0.2

package/dist/auth-client.d.ts

@@ -0,0 +1,38 @@
+import type { LoginRequest, LoginResponse, RegisterRequest, RegisterResponse, RefreshTokenRequest, RefreshTokenResponse, PasswordResetRequest, PasswordResetConfirmRequest, ChangePasswordRequest, MessageResponse } from "@longzai-intelligence-auth/core";
+import type { AuthUser } from "./types/auth-state.types";
+export type FetchFn = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
+export type AuthStrategyType = "jwt" | "standalone";
+export type AuthClientOptions = {
+    baseUrl: string;
+    apiPrefix?: string;
+    strategy?: AuthStrategyType;
+    fetchFn?: FetchFn;
+};
+export type BaseAuthClient = {
+    login(data: LoginRequest): Promise<LoginResponse>;
+    register(data: RegisterRequest): Promise<RegisterResponse>;
+    refreshToken(data: RefreshTokenRequest): Promise<RefreshTokenResponse>;
+    logout(accessToken: string): Promise<MessageResponse>;
+    getProfile(accessToken: string): Promise<{
+        user: AuthUser;
+    }>;
+    changePassword(accessToken: string, data: ChangePasswordRequest): Promise<MessageResponse>;
+    requestPasswordReset(data: PasswordResetRequest): Promise<MessageResponse>;
+    confirmPasswordReset(data: PasswordResetConfirmRequest): Promise<MessageResponse>;
+};
+export type JwtAuthClient = BaseAuthClient & {
+    verifyToken(accessToken: string): Promise<{
+        valid: boolean;
+        payload?: Record<string, unknown>;
+    }>;
+};
+export type AuthClient<T extends AuthStrategyType = "standalone"> = T extends "jwt" ? JwtAuthClient : BaseAuthClient;
+export declare class AuthClientError extends Error {
+    code: string;
+    statusCode: number;
+    constructor(code: string, message: string, statusCode: number);
+}
+export declare function createAuthClient<T extends AuthStrategyType>(options: AuthClientOptions & {
+    strategy: T;
+}): T extends "jwt" ? JwtAuthClient : BaseAuthClient;
+export declare function createAuthClient(options: AuthClientOptions): BaseAuthClient;

package/dist/auth-client.js

@@ -0,0 +1,95 @@
+export class AuthClientError extends Error {
+    code;
+    statusCode;
+    constructor(code, message, statusCode) {
+        super(message);
+        this.name = "AuthClientError";
+        this.code = code;
+        this.statusCode = statusCode;
+    }
+}
+async function httpGet(baseUrl, apiPrefix, fetchFn, path, accessToken) {
+    const headers = { "Content-Type": "application/json" };
+    if (accessToken) {
+        headers.Authorization = `Bearer ${accessToken}`;
+    }
+    const response = await fetchFn(`${baseUrl}${apiPrefix}${path}`, {
+        method: "GET",
+        headers,
+    });
+    return handleResponse(response);
+}
+async function httpPost(baseUrl, apiPrefix, fetchFn, path, body, accessToken) {
+    const headers = { "Content-Type": "application/json" };
+    if (accessToken) {
+        headers.Authorization = `Bearer ${accessToken}`;
+    }
+    const response = await fetchFn(`${baseUrl}${apiPrefix}${path}`, {
+        method: "POST",
+        headers,
+        body: body ? JSON.stringify(body) : undefined,
+    });
+    return handleResponse(response);
+}
+async function httpPut(baseUrl, apiPrefix, fetchFn, path, body, accessToken) {
+    const response = await fetchFn(`${baseUrl}${apiPrefix}${path}`, {
+        method: "PUT",
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${accessToken}`,
+        },
+        body: JSON.stringify(body),
+    });
+    return handleResponse(response);
+}
+async function handleResponse(response) {
+    if (!response.ok) {
+        const error = await response.json().catch(() => ({ message: "请求失败" }));
+        throw new AuthClientError(error.code ?? "UNKNOWN_ERROR", error.message ?? "请求失败", response.status);
+    }
+    return response.json();
+}
+function createBaseAuthClient(baseUrl, apiPrefix, fetchFn) {
+    return {
+        async login(data) {
+            return httpPost(baseUrl, apiPrefix, fetchFn, "/auth/login", data);
+        },
+        async register(data) {
+            return httpPost(baseUrl, apiPrefix, fetchFn, "/auth/register", data);
+        },
+        async refreshToken(data) {
+            return httpPost(baseUrl, apiPrefix, fetchFn, "/auth/refresh", data);
+        },
+        async logout(accessToken) {
+            return httpPost(baseUrl, apiPrefix, fetchFn, "/auth/logout", undefined, accessToken);
+        },
+        async getProfile(accessToken) {
+            return httpGet(baseUrl, apiPrefix, fetchFn, "/users/me", accessToken);
+        },
+        async changePassword(accessToken, data) {
+            return httpPut(baseUrl, apiPrefix, fetchFn, "/users/me/password", data, accessToken);
+        },
+        async requestPasswordReset(data) {
+            return httpPost(baseUrl, apiPrefix, fetchFn, "/auth/password-reset/request", data);
+        },
+        async confirmPasswordReset(data) {
+            return httpPost(baseUrl, apiPrefix, fetchFn, "/auth/password-reset/confirm", data);
+        },
+    };
+}
+export function createAuthClient(options) {
+    const baseUrl = options.baseUrl.replace(/\/$/, "");
+    const apiPrefix = options.apiPrefix ?? "/api/v1";
+    const strategy = options.strategy ?? "standalone";
+    const fetchFn = options.fetchFn ?? globalThis.fetch;
+    const base = createBaseAuthClient(baseUrl, apiPrefix, fetchFn);
+    if (strategy === "jwt") {
+        return {
+            ...base,
+            async verifyToken(accessToken) {
+                return httpPost(baseUrl, apiPrefix, fetchFn, "/auth/verify", undefined, accessToken);
+            },
+        };
+    }
+    return base;
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { createAuthClient, AuthClientError } from "./auth-client";
+export type { AuthClientOptions, AuthStrategyType, FetchFn, BaseAuthClient, JwtAuthClient, AuthClient } from "./auth-client";
+export { createTokenStorage } from "./token-storage";
+export type { TokenStorage } from "./token-storage";
+export { createTokenInterceptor, createRefreshInterceptor } from "./token-interceptor";
+export type { StorageType, AuthUser, SessionState, } from "./types/auth-state.types";

package/dist/index.js

@@ -0,0 +1,3 @@
+export { createAuthClient, AuthClientError } from "./auth-client";
+export { createTokenStorage } from "./token-storage";
+export { createTokenInterceptor, createRefreshInterceptor } from "./token-interceptor";

package/dist/token-interceptor.d.ts

@@ -0,0 +1,4 @@
+import type { TokenStorage } from "./token-storage";
+import type { BaseAuthClient, FetchFn } from "./auth-client";
+export declare function createTokenInterceptor(storage: TokenStorage, fetchFn?: FetchFn): FetchFn;
+export declare function createRefreshInterceptor(storage: TokenStorage, client: BaseAuthClient, fetchFn?: FetchFn): FetchFn;

package/dist/token-interceptor.js

@@ -0,0 +1,36 @@
+export function createTokenInterceptor(storage, fetchFn = globalThis.fetch) {
+    return async (input, init) => {
+        const token = storage.getToken();
+        const headers = new Headers(init?.headers);
+        if (token && !headers.has("Authorization")) {
+            headers.set("Authorization", `Bearer ${token}`);
+        }
+        return fetchFn(input, { ...init, headers });
+    };
+}
+export function createRefreshInterceptor(storage, client, fetchFn = globalThis.fetch) {
+    const tokenFetch = createTokenInterceptor(storage, fetchFn);
+    return async (input, init) => {
+        const response = await tokenFetch(input, init);
+        if (response.status === 401) {
+            const refreshToken = storage.getRefreshToken();
+            if (!refreshToken) {
+                storage.clear();
+                return response;
+            }
+            try {
+                const tokens = await client.refreshToken({ refreshToken });
+                storage.setToken(tokens.accessToken);
+                storage.setRefreshToken(tokens.refreshToken);
+                const newHeaders = new Headers(init?.headers);
+                newHeaders.set("Authorization", `Bearer ${tokens.accessToken}`);
+                return fetchFn(input, { ...init, headers: newHeaders });
+            }
+            catch {
+                storage.clear();
+                return response;
+            }
+        }
+        return response;
+    };
+}

package/dist/token-storage.d.ts

@@ -0,0 +1,11 @@
+import type { StorageType } from "./types/auth-state.types";
+export type TokenStorage = {
+    getToken(): string | null;
+    setToken(token: string): void;
+    removeToken(): void;
+    getRefreshToken(): string | null;
+    setRefreshToken(token: string): void;
+    removeRefreshToken(): void;
+    clear(): void;
+};
+export declare function createTokenStorage(type: StorageType): TokenStorage;

package/dist/token-storage.js

@@ -0,0 +1,64 @@
+export function createTokenStorage(type) {
+    switch (type) {
+        case "localStorage":
+            return new LocalStorageAdapter("localStorage");
+        case "sessionStorage":
+            return new LocalStorageAdapter("sessionStorage");
+        case "memory":
+            return new MemoryStorageAdapter();
+    }
+}
+class LocalStorageAdapter {
+    store;
+    constructor(storeType) {
+        this.store = globalThis[storeType];
+    }
+    getToken() {
+        return this.store.getItem("lzi_access_token");
+    }
+    setToken(token) {
+        this.store.setItem("lzi_access_token", token);
+    }
+    removeToken() {
+        this.store.removeItem("lzi_access_token");
+    }
+    getRefreshToken() {
+        return this.store.getItem("lzi_refresh_token");
+    }
+    setRefreshToken(token) {
+        this.store.setItem("lzi_refresh_token", token);
+    }
+    removeRefreshToken() {
+        this.store.removeItem("lzi_refresh_token");
+    }
+    clear() {
+        this.removeToken();
+        this.removeRefreshToken();
+    }
+}
+class MemoryStorageAdapter {
+    accessToken = null;
+    refreshToken = null;
+    getToken() {
+        return this.accessToken;
+    }
+    setToken(token) {
+        this.accessToken = token;
+    }
+    removeToken() {
+        this.accessToken = null;
+    }
+    getRefreshToken() {
+        return this.refreshToken;
+    }
+    setRefreshToken(token) {
+        this.refreshToken = token;
+    }
+    removeRefreshToken() {
+        this.refreshToken = null;
+    }
+    clear() {
+        this.removeToken();
+        this.removeRefreshToken();
+    }
+}

package/dist/types/auth-state.types.d.ts

@@ -0,0 +1,13 @@
+import type { UserInfo } from "@longzai-intelligence-auth/core";
+export type StorageType = "localStorage" | "sessionStorage" | "memory";
+export interface AuthUser extends UserInfo {
+    email: string;
+    name: string;
+    avatar?: string;
+}
+export type SessionState = {
+    user: AuthUser | null;
+    isLoading: boolean;
+    isAuthenticated: boolean;
+    error: string | null;
+};

package/dist/types/auth-state.types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@longzai-intelligence-auth/sdk",
+  "version": "0.0.2",
+  "license": "UNLICENSED",
+  "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"
+      }
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "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"
+  },
+  "devDependencies": {}
+}