@lobehub/lobehub 2.0.0-next.161 → 2.0.0-next.163

package/src/libs/redis/upstash.test.ts

@@ -5,7 +5,7 @@
 //
 // Read more here: https://github.com/capricorn86/happy-dom/issues/1042#issuecomment-3585851354
 import { Buffer } from 'node:buffer';
-import { describe, expect, it, vi } from 'vitest';
+import { afterEach, describe, expect, it, vi } from 'vitest';
 
 import { UpstashConfig } from './types';
 
@@ -139,9 +139,9 @@ describe('mocked', () => {
     await provider.hset(bufKey, 'field', 'value');
     await provider.del(bufKey);
 
-    expect(mocks.mockSet).toHaveBeenCalledWith('buffer-key', 'value', undefined);
-    expect(mocks.mockHset).toHaveBeenCalledWith('buffer-key', { field: 'value' });
-    expect(mocks.mockDel).toHaveBeenCalledWith('buffer-key');
+    expect(mocks.mockSet).toHaveBeenCalledWith('mock:buffer-key', 'value', undefined);
+    expect(mocks.mockHset).toHaveBeenCalledWith('mock:buffer-key', { field: 'value' });
+    expect(mocks.mockDel).toHaveBeenCalledWith('mock:buffer-key');
   });
 
   it('passes set options through to upstash client', async () => {
@@ -149,6 +149,10 @@ describe('mocked', () => {
 
     await provider.set('key', 'value', { ex: 10, nx: true, get: true });
 
-    expect(mocks.mockSet).toHaveBeenCalledWith('key', 'value', { ex: 10, nx: true, get: true });
+    expect(mocks.mockSet).toHaveBeenCalledWith('mock:key', 'value', {
+      ex: 10,
+      nx: true,
+      get: true,
+    });
   });
 });

package/src/libs/redis/upstash.ts

@@ -20,9 +20,28 @@ import {
 export class UpstashRedisProvider implements BaseRedisProvider {
   provider: 'upstash' = 'upstash';
   private client: Redis;
+  private readonly prefix: string;
 
   constructor(options: UpstashConfig | RedisConfigNodejs) {
-    this.client = new Redis(options as RedisConfigNodejs);
+    const { prefix, ...clientOptions } = options as UpstashConfig & RedisConfigNodejs;
+    this.prefix = prefix ? `${prefix}:` : '';
+    this.client = new Redis(clientOptions as RedisConfigNodejs);
+  }
+
+  /**
+   * Build a fully qualified key assuming the input was already normalized.
+   * Avoids re-running normalization when callers have normalized keys (e.g. mset).
+   */
+  private addPrefixToKey(normalizedKey: string) {
+    return `${this.prefix}${normalizedKey}`;
+  }
+
+  private buildKey(key: RedisKey) {
+    return this.addPrefixToKey(normalizeRedisKey(key));
+  }
+
+  private buildKeys(keys: RedisKey[]) {
+    return normalizeRedisKeys(keys).map((key) => `${this.prefix}${key}`);
   }
 
   async initialize(): Promise<void> {
@@ -34,15 +53,11 @@ export class UpstashRedisProvider implements BaseRedisProvider {
   }
 
   async get(key: RedisKey): Promise<string | null> {
-    return this.client.get(normalizeRedisKey(key));
+    return this.client.get(this.buildKey(key));
   }
 
   async set(key: RedisKey, value: RedisValue, options?: SetOptions): Promise<RedisSetResult> {
-    const res = await this.client.set(
-      normalizeRedisKey(key),
-      value,
-      buildUpstashSetOptions(options),
-    );
+    const res = await this.client.set(this.buildKey(key), value, buildUpstashSetOptions(options));
     if (Buffer.isBuffer(res)) {
       return res.toString();
     }
@@ -51,55 +66,64 @@ export class UpstashRedisProvider implements BaseRedisProvider {
   }
 
   async setex(key: RedisKey, seconds: number, value: RedisValue): Promise<'OK'> {
-    return this.client.setex(normalizeRedisKey(key), seconds, value);
+    return this.client.setex(this.buildKey(key), seconds, value);
   }
 
   async del(...keys: RedisKey[]): Promise<number> {
-    return this.client.del(...normalizeRedisKeys(keys));
+    return this.client.del(...this.buildKeys(keys));
   }
 
   async exists(...keys: RedisKey[]): Promise<number> {
-    return this.client.exists(...normalizeRedisKeys(keys));
+    return this.client.exists(...this.buildKeys(keys));
   }
 
   async expire(key: RedisKey, seconds: number): Promise<number> {
-    return this.client.expire(normalizeRedisKey(key), seconds);
+    return this.client.expire(this.buildKey(key), seconds);
   }
 
   async ttl(key: RedisKey): Promise<number> {
-    return this.client.ttl(normalizeRedisKey(key));
+    return this.client.ttl(this.buildKey(key));
   }
 
   async incr(key: RedisKey): Promise<number> {
-    return this.client.incr(normalizeRedisKey(key));
+    return this.client.incr(this.buildKey(key));
   }
 
   async decr(key: RedisKey): Promise<number> {
-    return this.client.decr(normalizeRedisKey(key));
+    return this.client.decr(this.buildKey(key));
   }
 
   async mget(...keys: RedisKey[]): Promise<(string | null)[]> {
-    return this.client.mget(...normalizeRedisKeys(keys));
+    return this.client.mget(...this.buildKeys(keys));
   }
 
   async mset(values: RedisMSetArgument): Promise<'OK'> {
-    return this.client.mset(normalizeMsetValues(values));
+    const normalized = normalizeMsetValues(values);
+    const prefixed = Object.entries(normalized).reduce<Record<string, RedisValue>>(
+      (acc, [key, value]) => {
+        acc[this.addPrefixToKey(key)] = value;
+        return acc;
+      },
+      {},
+    );
+
+    return this.client.mset(prefixed);
   }
 
   async hget(key: RedisKey, field: RedisKey): Promise<string | null> {
-    return this.client.hget(normalizeRedisKey(key), normalizeRedisKey(field));
+    return this.client.hget(this.buildKey(key), normalizeRedisKey(field));
   }
 
   async hset(key: RedisKey, field: RedisKey, value: RedisValue): Promise<number> {
-    return this.client.hset(normalizeRedisKey(key), { [normalizeRedisKey(field)]: value });
+    return this.client.hset(this.buildKey(key), { [normalizeRedisKey(field)]: value });
   }
 
   async hdel(key: RedisKey, ...fields: RedisKey[]): Promise<number> {
-    return this.client.hdel(normalizeRedisKey(key), ...normalizeRedisKeys(fields));
+    return this.client.hdel(this.buildKey(key), ...normalizeRedisKeys(fields));
   }
 
   async hgetall(key: RedisKey): Promise<Record<string, string>> {
-    const res = await this.client.hgetall(normalizeRedisKey(key));
+    const res = await this.client.hgetall(this.buildKey(key));
     if (!res) {
       return {};
     }

package/src/locales/default/authError.ts

@@ -0,0 +1,40 @@
+export default {
+  actions: {
+    discord: '前往 Discord 反馈',
+    home: '返回首页',
+    retry: '重新登录',
+  },
+  codes: {
+    ACCOUNT_ALREADY_LINKED_TO_DIFFERENT_USER: '该账号已关联至其他用户',
+    ACCOUNT_NOT_FOUND: '未找到对应账号',
+    CREDENTIAL_ACCOUNT_NOT_FOUND: '凭证账号不存在',
+    EMAIL_CAN_NOT_BE_UPDATED: '当前账号邮箱不可修改',
+    EMAIL_NOT_VERIFIED: '请先完成邮箱验证',
+    FAILED_TO_CREATE_SESSION: '创建会话失败',
+    FAILED_TO_CREATE_USER: '创建用户失败',
+    FAILED_TO_GET_SESSION: '获取会话失败',
+    FAILED_TO_GET_USER_INFO: '获取用户信息失败',
+    FAILED_TO_UNLINK_LAST_ACCOUNT: '无法解绑最后一个关联账号',
+    FAILED_TO_UPDATE_USER: '更新用户信息失败',
+    ID_TOKEN_NOT_SUPPORTED: '当前身份令牌不被支持',
+    INVALID_EMAIL: '邮箱格式不正确',
+    INVALID_EMAIL_OR_PASSWORD: '邮箱或密码错误',
+    INVALID_PASSWORD: '密码格式无效',
+    INVALID_TOKEN: '令牌无效或已过期',
+    PASSWORD_TOO_LONG: '密码长度过长',
+    PASSWORD_TOO_SHORT: '密码长度过短',
+    PROVIDER_NOT_FOUND: '未找到对应的身份提供方配置',
+    RATE_LIMIT_EXCEEDED: '请求过于频繁，请稍后再试',
+    SESSION_EXPIRED: '会话已过期，请重新登录',
+    SOCIAL_ACCOUNT_ALREADY_LINKED: '该社交账号已被其他用户绑定',
+    UNEXPECTED_ERROR: '发生未知错误，请重试',
+    UNKNOWN: '发生未知错误，请重试或联系支持',
+    USER_ALREADY_EXISTS: '用户已存在',
+    USER_ALREADY_EXISTS_USE_ANOTHER_EMAIL: '邮箱已被使用，请尝试其他邮箱',
+    USER_ALREADY_HAS_PASSWORD: '该账号已设置密码',
+    USER_BANNED: '该用户已被封禁',
+    USER_EMAIL_NOT_FOUND: '未找到对应邮箱',
+    USER_NOT_FOUND: '未找到用户',
+  },
+  title: '身份验证出错',
+};

package/src/locales/default/index.ts

@@ -1,4 +1,5 @@
 import auth from './auth';
+import authError from './authError';
 import changelog from './changelog';
 import chat from './chat';
 import clerk from './clerk';
@@ -33,6 +34,7 @@ import welcome from './welcome';
 
 const resources = {
   auth,
+  authError,
   changelog,
   chat,
   clerk,

package/src/proxy.ts

@@ -52,6 +52,7 @@ export const config = {
     '/signin(.*)',
     '/verify-email(.*)',
     '/reset-password(.*)',
+    '/auth-error(.*)',
     '/next-auth/(.*)',
     '/oauth(.*)',
     '/oidc(.*)',