@lobehub/lobehub 2.0.0-next.354 → 2.0.0-next.356

package/src/libs/next-auth/sso-providers/logto.ts

@@ -1,48 +0,0 @@
-import { type OIDCConfig, type OIDCUserConfig } from '@auth/core/providers';
-
-import { CommonProviderConfig } from './sso.config';
-
-interface LogtoProfile extends Record<string, any> {
-  email: string;
-  id: string;
-  name?: string;
-  picture: string;
-  sub: string;
-  username: string;
-}
-
-function LobeLogtoProvider(config: OIDCUserConfig<LogtoProfile>): OIDCConfig<LogtoProfile> {
-  return {
-    ...CommonProviderConfig,
-    ...config,
-    id: 'logto',
-    name: 'Logto',
-    profile(profile) {
-      // You can customize the user profile mapping here
-      return {
-        email: profile.email,
-        id: profile.sub,
-        image: profile.picture,
-        name: profile.name ?? profile.username ?? profile.email,
-        providerAccountId: profile.sub,
-      };
-    },
-    type: 'oidc',
-  };
-}
-
-const provider = {
-  id: 'logto',
-  provider: LobeLogtoProvider({
-    authorization: {
-      params: { scope: 'openid offline_access profile email' },
-    },
-    // You can get the issuer value from the Logto Application Details page,
-    // in the field "Issuer endpoint"
-    clientId: process.env.AUTH_LOGTO_ID,
-    clientSecret: process.env.AUTH_LOGTO_SECRET,
-    issuer: process.env.AUTH_LOGTO_ISSUER,
-  }),
-};
-
-export default provider;

package/src/libs/next-auth/sso-providers/microsoft-entra-id-helper.ts

@@ -1,29 +0,0 @@
-import { authEnv } from '@/envs/auth';
-
-function getTenantId() {
-  return (
-    process.env.AUTH_MICROSOFT_ENTRA_ID_TENANT_ID ??
-    process.env.AUTH_AZURE_AD_TENANT_ID ??
-    authEnv.AZURE_AD_TENANT_ID
-  );
-}
-
-function getClientLoginBaseUrl() {
-  return process.env.AUTH_MICROSOFT_ENTRA_ID_BASE_URL ?? 'https://login.microsoftonline.com';
-}
-
-function getIssuer() {
-  const issuer = process.env.MICROSOFT_ENTRA_ID_ISSUER;
-  if (issuer) {
-    return issuer;
-  }
-  const tenantId = getTenantId();
-  if (tenantId) {
-    // refs: https://github.com/nextauthjs/next-auth/discussions/9154#discussioncomment-10583104
-    return `${getClientLoginBaseUrl()}/${tenantId}/v2.0`;
-  } else {
-    return undefined;
-  }
-}
-
-export { getIssuer as getMicrosoftEntraIdIssuer, getTenantId as getMicrosoftEntraIdTenantId };

package/src/libs/next-auth/sso-providers/microsoft-entra-id.ts

@@ -1,19 +0,0 @@
-import MicrosoftEntraID from 'next-auth/providers/microsoft-entra-id';
-
-import { getMicrosoftEntraIdIssuer } from './microsoft-entra-id-helper';
-import { CommonProviderConfig } from './sso.config';
-
-const provider = {
-  id: 'microsoft-entra-id',
-  provider: MicrosoftEntraID({
-    ...CommonProviderConfig,
-    // Specify auth scope, at least include 'openid email'
-    // all scopes in Azure AD ref: https://learn.microsoft.com/en-us/entra/identity-platform/scopes-oidc#openid-connect-scopes
-    authorization: { params: { scope: 'openid email profile' } },
-    clientId: process.env.AUTH_MICROSOFT_ENTRA_ID_ID ?? process.env.AUTH_AZURE_AD_ID,
-    clientSecret: process.env.AUTH_MICROSOFT_ENTRA_ID_SECRET ?? process.env.AUTH_AZURE_AD_SECRET,
-    issuer: getMicrosoftEntraIdIssuer(),
-  }),
-};
-
-export default provider;

package/src/libs/next-auth/sso-providers/okta.ts

@@ -1,22 +0,0 @@
-import Okta from 'next-auth/providers/okta';
-
-import { CommonProviderConfig } from './sso.config';
-
-const provider = {
-  id: 'okta',
-  provider: Okta({
-    ...CommonProviderConfig,
-    authorization: { params: { scope: 'openid email profile' } },
-    profile(profile) {
-      return {
-        email: profile.email,
-        id: profile.sub,
-        image: profile.picture,
-        name: profile.name ?? profile.preferred_username,
-        providerAccountId: profile.sub,
-      };
-    },
-  }),
-};
-
-export default provider;

package/src/libs/next-auth/sso-providers/sso.config.ts

@@ -1,8 +0,0 @@
-import { type OAuth2Config } from '@auth/core/providers';
-import type { Profile } from 'next-auth';
-
-export const CommonProviderConfig = {
-  // Auth.js does not allow email account linking by default cause it's dangerous
-  // ref: https://authjs.dev/reference/core/providers#allowdangerousemailaccountlinking
-  allowDangerousEmailAccountLinking: true,
-} satisfies Partial<OAuth2Config<Profile>>;

package/src/libs/next-auth/sso-providers/wechat.ts

@@ -1,36 +0,0 @@
-import WeChat, { type WeChatProfile } from '@auth/core/providers/wechat';
-
-import { CommonProviderConfig } from './sso.config';
-
-const provider = {
-  id: 'wechat',
-  provider: WeChat({
-    ...CommonProviderConfig,
-    clientId: process.env.AUTH_WECHAT_ID,
-    clientSecret: process.env.AUTH_WECHAT_SECRET,
-    platformType: 'WebsiteApp',
-    profile: (profile: WeChatProfile) => {
-      return {
-        email: null,
-        id: profile.unionid,
-        image: profile.headimgurl,
-        name: profile.nickname,
-        providerAccountId: profile.unionid,
-      };
-    },
-    style: { bg: '#fff', logo: 'https://authjs.dev/img/providers/wechat.svg', text: '#000' },
-    token: {
-      async conform(response: Response) {
-        const data = await response.json();
-        console.log('wechat data:', data);
-        return new Response(JSON.stringify({ ...data, token_type: 'bearer' }), {
-          headers: { 'Content-Type': 'application/json' },
-        });
-      },
-      params: { appid: process.env.AUTH_WECHAT_ID, secret: process.env.AUTH_WECHAT_SECRET },
-      url: 'https://api.weixin.qq.com/sns/oauth2/access_token',
-    },
-  }),
-};
-
-export default provider;

package/src/libs/next-auth/sso-providers/zitadel.ts

@@ -1,21 +0,0 @@
-import Zitadel from 'next-auth/providers/zitadel';
-
-const provider = {
-  id: 'zitadel',
-  provider: Zitadel({
-    // Available scopes in ZITADEL: https://zitadel.com/docs/apis/openidoauth/scopes
-    authorization: { params: { scope: 'openid email profile' } },
-    // TODO(NextAuth): map unique user id to `providerAccountId` field
-    // profile(profile) {
-    //   return {
-    //     email: profile.email,
-    //     image: profile.picture,
-    //     name: profile.name,
-    //     providerAccountId: profile.user_id,
-    //     id: profile.user_id,
-    //   };
-    // },
-  }),
-};
-
-export default provider;

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

@@ -1,158 +0,0 @@
-// @vitest-environment node
-// NOTICE: here due to the reason we are using [`happy-dom`](https://github.com/lobehub/lobe-chat/blob/13753145557a9dede98b1f5489f93ac570ef2956/vitest.config.mts#L45)
-// for Vitest environment, and in fact that this is a known bug for happy-dom not including
-// Authorization header in fetch requests.
-//
-// Read more here: https://github.com/capricorn86/happy-dom/issues/1042#issuecomment-3585851354
-import { Buffer } from 'node:buffer';
-import { afterEach, describe, expect, it, vi } from 'vitest';
-
-import { UpstashConfig } from './types';
-
-const buildUpstashConfig = (): UpstashConfig | null => {
-  const url = process.env.UPSTASH_REDIS_REST_URL;
-  const token = process.env.UPSTASH_REDIS_REST_TOKEN;
-
-  if (!url || !token) return null;
-
-  return {
-    enabled: true,
-    prefix: process.env.REDIS_PREFIX ?? 'lobe-chat-test',
-    provider: 'upstash',
-    token,
-    url,
-  };
-};
-
-const loadUpstashProvider = async () => (await import('./upstash')).UpstashRedisProvider;
-
-const createMockedProvider = async () => {
-  const mocks = {
-    mockSet: vi.fn().mockResolvedValue('OK'),
-    mockGet: vi.fn().mockResolvedValue('mock-value'),
-    mockDel: vi.fn().mockResolvedValue(1),
-    mockSetex: vi.fn().mockResolvedValue('OK'),
-    mockMset: vi.fn().mockResolvedValue('OK'),
-    mockHset: vi.fn().mockResolvedValue(1),
-    mockHdel: vi.fn().mockResolvedValue(1),
-    mockHgetall: vi.fn().mockResolvedValue({ a: '1' }),
-    mockPing: vi.fn().mockResolvedValue('PONG'),
-    mockExists: vi.fn().mockResolvedValue(1),
-    mockExpire: vi.fn().mockResolvedValue(1),
-    mockTtl: vi.fn().mockResolvedValue(50),
-    mockIncr: vi.fn().mockResolvedValue(2),
-    mockDecr: vi.fn().mockResolvedValue(0),
-    mockMget: vi.fn().mockResolvedValue(['a', 'b']),
-    mockHget: vi.fn().mockResolvedValue('field'),
-  };
-
-  vi.resetModules();
-  vi.doMock('@upstash/redis', () => {
-    class FakeRedis {
-      constructor(public config: any) {}
-      ping = mocks.mockPing;
-      set = mocks.mockSet;
-      get = mocks.mockGet;
-      del = mocks.mockDel;
-      setex = mocks.mockSetex;
-      exists = mocks.mockExists;
-      expire = mocks.mockExpire;
-      ttl = mocks.mockTtl;
-      incr = mocks.mockIncr;
-      decr = mocks.mockDecr;
-      mget = mocks.mockMget;
-      mset = mocks.mockMset;
-      hget = mocks.mockHget;
-      hset = mocks.mockHset;
-      hdel = mocks.mockHdel;
-      hgetall = mocks.mockHgetall;
-    }
-
-    return { Redis: FakeRedis };
-  });
-
-  const UpstashRedisProvider = await loadUpstashProvider();
-  const provider = new UpstashRedisProvider({
-    enabled: true,
-    prefix: 'mock',
-    provider: 'upstash',
-    token: 'token',
-    url: 'https://example.upstash.io',
-  });
-
-  await provider.initialize();
-
-  return { mocks, provider };
-};
-
-const shouldSkipIntegration = (error: unknown) =>
-  error instanceof Error &&
-  ['ENOTFOUND', 'ECONNREFUSED', 'EAI_AGAIN', 'Connection is closed'].some((msg) =>
-    error.message.includes(msg),
-  );
-
-afterEach(() => {
-  vi.clearAllMocks();
-  vi.resetModules();
-  vi.unmock('@upstash/redis');
-});
-
-describe('integrated', (test) => {
-  const config = buildUpstashConfig();
-  if (!config) {
-    test.skip('UPSTASH_REDIS_REST_URL/TOKEN not provided; skip integrated upstash tests');
-    return;
-  }
-
-  it('set -> get -> del roundtrip', async () => {
-    vi.unmock('@upstash/redis');
-    vi.resetModules();
-
-    const UpstashRedisProvider = await loadUpstashProvider();
-    const provider = new UpstashRedisProvider(config);
-    try {
-      await provider.initialize();
-
-      const key = `upstash:test:${Date.now()}`;
-      await provider.set(key, 'value', { ex: 60 });
-      expect(await provider.get(key)).toBe('value');
-      expect(await provider.del(key)).toBe(1);
-    } catch (error) {
-      if (shouldSkipIntegration(error)) {
-        // Remote Upstash Redis unavailable in current environment; treat as skipped.
-        return;
-      }
-
-      throw error;
-    } finally {
-      await provider.disconnect();
-    }
-  });
-});
-
-describe('mocked', () => {
-  it('normalizes buffer keys to strings', async () => {
-    const { mocks, provider } = await createMockedProvider();
-
-    const bufKey = Buffer.from('buffer-key');
-    await provider.set(bufKey, 'value');
-    await provider.hset(bufKey, 'field', 'value');
-    await provider.del(bufKey);
-
-    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 () => {
-    const { mocks, provider } = await createMockedProvider();
-
-    await provider.set('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

@@ -1,136 +0,0 @@
-import { Redis, type RedisConfigNodejs } from '@upstash/redis';
-import { Buffer } from 'node:buffer';
-
-import {
-  type BaseRedisProvider,
-  type RedisKey,
-  type RedisMSetArgument,
-  type RedisSetResult,
-  type RedisValue,
-  type SetOptions,
-  type UpstashConfig,
-} from './types';
-import {
-  buildUpstashSetOptions,
-  normalizeMsetValues,
-  normalizeRedisKey,
-  normalizeRedisKeys,
-} from './utils';
-
-export class UpstashRedisProvider implements BaseRedisProvider {
-  provider: 'upstash' = 'upstash';
-  private client: Redis;
-  private readonly prefix: string;
-
-  constructor(options: UpstashConfig | RedisConfigNodejs) {
-    const { prefix, ...clientOptions } = options as UpstashConfig & RedisConfigNodejs;
-    this.prefix = prefix ? `${prefix}:` : '';
-    this.client = new Redis({
-      ...clientOptions,
-      automaticDeserialization: false,
-    } 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> {
-    await this.client.ping();
-  }
-
-  async disconnect() {
-    // upstash client is stateless http, nothing to disconnect
-  }
-
-  async get(key: RedisKey): Promise<string | null> {
-    return this.client.get(this.buildKey(key));
-  }
-
-  async set(key: RedisKey, value: RedisValue, options?: SetOptions): Promise<RedisSetResult> {
-    const res = await this.client.set(this.buildKey(key), value, buildUpstashSetOptions(options));
-    if (Buffer.isBuffer(res)) {
-      return res.toString();
-    }
-
-    return res;
-  }
-
-  async setex(key: RedisKey, seconds: number, value: RedisValue): Promise<'OK'> {
-    return this.client.setex(this.buildKey(key), seconds, value);
-  }
-
-  async del(...keys: RedisKey[]): Promise<number> {
-    return this.client.del(...this.buildKeys(keys));
-  }
-
-  async exists(...keys: RedisKey[]): Promise<number> {
-    return this.client.exists(...this.buildKeys(keys));
-  }
-
-  async expire(key: RedisKey, seconds: number): Promise<number> {
-    return this.client.expire(this.buildKey(key), seconds);
-  }
-
-  async ttl(key: RedisKey): Promise<number> {
-    return this.client.ttl(this.buildKey(key));
-  }
-
-  async incr(key: RedisKey): Promise<number> {
-    return this.client.incr(this.buildKey(key));
-  }
-
-  async decr(key: RedisKey): Promise<number> {
-    return this.client.decr(this.buildKey(key));
-  }
-
-  async mget(...keys: RedisKey[]): Promise<(string | null)[]> {
-    return this.client.mget(...this.buildKeys(keys));
-  }
-
-  async mset(values: RedisMSetArgument): Promise<'OK'> {
-    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(this.buildKey(key), normalizeRedisKey(field));
-  }
-
-  async hset(key: RedisKey, field: RedisKey, value: RedisValue): Promise<number> {
-    return this.client.hset(this.buildKey(key), { [normalizeRedisKey(field)]: value });
-  }
-
-  async hdel(key: RedisKey, ...fields: RedisKey[]): Promise<number> {
-    return this.client.hdel(this.buildKey(key), ...normalizeRedisKeys(fields));
-  }
-
-  async hgetall(key: RedisKey): Promise<Record<string, string>> {
-    const res = await this.client.hgetall(this.buildKey(key));
-    if (!res) {
-      return {};
-    }
-
-    return res as Record<string, string>;
-  }
-}