refactor(server): plugin modules (#5630)

- [x] separates modules into `fundamental`, `core`, `plugins`
- [x] optional modules with `@OptionalModule` decorator to install modules with requirements met(`requires`, `if`)
- [x] `module.contributesTo` defines optional features that will be enabled if module registered
- [x] `AFFiNE.plugins.use('payment', {})` to enable a optional/plugin module
- [x] `PaymentModule` is the first plugin module
- [x] GraphQLSchema will not be generated for non-included modules
- [x] Frontend can use `ServerConfigType` query to detect which features are enabled
- [x] override existing provider globally

packages/backend/server/src/fundamentals/cache/def.ts

@@ -0,0 +1,49 @@
+export interface CacheSetOptions {
+  // in milliseconds
+  ttl?: number;
+}
+
+// extends if needed
+export interface Cache {
+  // standard operation
+  get<T = unknown>(key: string): Promise<T | undefined>;
+  set<T = unknown>(
+    key: string,
+    value: T,
+    opts?: CacheSetOptions
+  ): Promise<boolean>;
+  setnx<T = unknown>(
+    key: string,
+    value: T,
+    opts?: CacheSetOptions
+  ): Promise<boolean>;
+  increase(key: string, count?: number): Promise<number>;
+  decrease(key: string, count?: number): Promise<number>;
+  delete(key: string): Promise<boolean>;
+  has(key: string): Promise<boolean>;
+  ttl(key: string): Promise<number>;
+  expire(key: string, ttl: number): Promise<boolean>;
+
+  // list operations
+  pushBack<T = unknown>(key: string, ...values: T[]): Promise<number>;
+  pushFront<T = unknown>(key: string, ...values: T[]): Promise<number>;
+  len(key: string): Promise<number>;
+  list<T = unknown>(key: string, start: number, end: number): Promise<T[]>;
+  popFront<T = unknown>(key: string, count?: number): Promise<T[]>;
+  popBack<T = unknown>(key: string, count?: number): Promise<T[]>;
+
+  // map operations
+  mapSet<T = unknown>(
+    map: string,
+    key: string,
+    value: T,
+    opts: CacheSetOptions
+  ): Promise<boolean>;
+  mapIncrease(map: string, key: string, count?: number): Promise<number>;
+  mapDecrease(map: string, key: string, count?: number): Promise<number>;
+  mapGet<T = unknown>(map: string, key: string): Promise<T | undefined>;
+  mapDelete(map: string, key: string): Promise<boolean>;
+  mapKeys(map: string): Promise<string[]>;
+  mapRandomKey(map: string): Promise<string | undefined>;
+  mapLen(map: string): Promise<number>;
+}

packages/backend/server/src/fundamentals/cache/index.ts

@@ -1,35 +1,13 @@
-import { Global, Module, Provider, Type } from '@nestjs/common';
-import { Redis } from 'ioredis';
+import { Global, Module } from '@nestjs/common';
 
-import { SessionCache, ThrottlerCache } from './instances';
-import { LocalCache } from './providers/cache';
-import { RedisCache } from './providers/redis';
-import { CacheRedis, RedisModule, SessionRedis, ThrottlerRedis } from './redis';
-
-function makeCacheProvider(CacheToken: Type, RedisToken: Type): Provider {
-  return {
-    provide: CacheToken,
-    useFactory: (redis?: Redis) => {
-      return redis ? new RedisCache(redis) : new LocalCache();
-    },
-    inject: [{ token: RedisToken, optional: true }],
-  };
-}
-
-const CacheProvider = makeCacheProvider(LocalCache, CacheRedis);
-const SessionCacheProvider = makeCacheProvider(SessionCache, SessionRedis);
-const ThrottlerCacheProvider = makeCacheProvider(
-  ThrottlerCache,
-  ThrottlerRedis
-);
+import { Cache, SessionCache } from './instances';
 
 @Global()
 @Module({
-  imports: AFFiNE.redis.enabled ? [RedisModule] : [],
-  providers: [CacheProvider, SessionCacheProvider, ThrottlerCacheProvider],
-  exports: [CacheProvider, SessionCacheProvider, ThrottlerCacheProvider],
+  providers: [Cache, SessionCache],
+  exports: [Cache, SessionCache],
 })
 export class CacheModule {}
-export { LocalCache as Cache, SessionCache, ThrottlerCache };
+export { Cache, SessionCache };
 
 export { CacheInterceptor, MakeCache, PreventCache } from './interceptor';

packages/backend/server/src/fundamentals/cache/instances.ts

@@ -1,4 +1,13 @@
-import { LocalCache } from './providers/cache';
+import { Injectable } from '@nestjs/common';
 
-export class SessionCache extends LocalCache {}
-export class ThrottlerCache extends LocalCache {}
+import { LocalCache } from './local';
+
+@Injectable()
+export class Cache extends LocalCache {}
+
+@Injectable()
+export class SessionCache extends LocalCache {
+  constructor() {
+    super({ namespace: 'session' });
+  }
+}

packages/backend/server/src/fundamentals/cache/interceptor.ts

@@ -10,7 +10,7 @@ import { Reflector } from '@nestjs/core';
 import { GqlContextType, GqlExecutionContext } from '@nestjs/graphql';
 import { mergeMap, Observable, of } from 'rxjs';
 
-import { LocalCache } from './providers/cache';
+import { Cache } from './instances';
 
 export const MakeCache = (key: string[], args?: string[]) =>
   SetMetadata('cacheKey', [key, args]);
@@ -24,7 +24,7 @@ export class CacheInterceptor implements NestInterceptor {
   private readonly logger = new Logger(CacheInterceptor.name);
   constructor(
     private readonly reflector: Reflector,
-    private readonly cache: LocalCache
+    private readonly cache: Cache
   ) {}
   async intercept(
     ctx: ExecutionContext,

packages/backend/server/src/fundamentals/cache/local.ts

@@ -1,57 +1,7 @@
-import { Injectable } from '@nestjs/common';
 import Keyv from 'keyv';
 
-export interface CacheSetOptions {
-  // in milliseconds
-  ttl?: number;
-}
+import type { Cache, CacheSetOptions } from './def';
 
-// extends if needed
-export interface Cache {
-  // standard operation
-  get<T = unknown>(key: string): Promise<T | undefined>;
-  set<T = unknown>(
-    key: string,
-    value: T,
-    opts?: CacheSetOptions
-  ): Promise<boolean>;
-  setnx<T = unknown>(
-    key: string,
-    value: T,
-    opts?: CacheSetOptions
-  ): Promise<boolean>;
-  increase(key: string, count?: number): Promise<number>;
-  decrease(key: string, count?: number): Promise<number>;
-  delete(key: string): Promise<boolean>;
-  has(key: string): Promise<boolean>;
-  ttl(key: string): Promise<number>;
-  expire(key: string, ttl: number): Promise<boolean>;
-
-  // list operations
-  pushBack<T = unknown>(key: string, ...values: T[]): Promise<number>;
-  pushFront<T = unknown>(key: string, ...values: T[]): Promise<number>;
-  len(key: string): Promise<number>;
-  list<T = unknown>(key: string, start: number, end: number): Promise<T[]>;
-  popFront<T = unknown>(key: string, count?: number): Promise<T[]>;
-  popBack<T = unknown>(key: string, count?: number): Promise<T[]>;
-
-  // map operations
-  mapSet<T = unknown>(
-    map: string,
-    key: string,
-    value: T,
-    opts: CacheSetOptions
-  ): Promise<boolean>;
-  mapIncrease(map: string, key: string, count?: number): Promise<number>;
-  mapDecrease(map: string, key: string, count?: number): Promise<number>;
-  mapGet<T = unknown>(map: string, key: string): Promise<T | undefined>;
-  mapDelete(map: string, key: string): Promise<boolean>;
-  mapKeys(map: string): Promise<string[]>;
-  mapRandomKey(map: string): Promise<string | undefined>;
-  mapLen(map: string): Promise<number>;
-}
-
-@Injectable()
 export class LocalCache implements Cache {
   private readonly kv: Keyv;
 

packages/backend/server/src/fundamentals/cache/providers/redis.ts

@@ -1,194 +0,0 @@
-import { Redis } from 'ioredis';
-
-import { Cache, CacheSetOptions } from './cache';
-
-export class RedisCache implements Cache {
-  constructor(private readonly redis: Redis) {}
-
-  // standard operation
-  async get<T = unknown>(key: string): Promise<T> {
-    return this.redis
-      .get(key)
-      .then(v => {
-        if (v) {
-          return JSON.parse(v);
-        }
-        return undefined;
-      })
-      .catch(() => undefined);
-  }
-
-  async set<T = unknown>(
-    key: string,
-    value: T,
-    opts: CacheSetOptions = {}
-  ): Promise<boolean> {
-    if (opts.ttl) {
-      return this.redis
-        .set(key, JSON.stringify(value), 'PX', opts.ttl)
-        .then(() => true)
-        .catch(() => false);
-    }
-
-    return this.redis
-      .set(key, JSON.stringify(value))
-      .then(() => true)
-      .catch(() => false);
-  }
-
-  async increase(key: string, count: number = 1): Promise<number> {
-    return this.redis.incrby(key, count).catch(() => 0);
-  }
-
-  async decrease(key: string, count: number = 1): Promise<number> {
-    return this.redis.decrby(key, count).catch(() => 0);
-  }
-
-  async setnx<T = unknown>(
-    key: string,
-    value: T,
-    opts: CacheSetOptions = {}
-  ): Promise<boolean> {
-    if (opts.ttl) {
-      return this.redis
-        .set(key, JSON.stringify(value), 'PX', opts.ttl, 'NX')
-        .then(v => !!v)
-        .catch(() => false);
-    }
-
-    return this.redis
-      .set(key, JSON.stringify(value), 'NX')
-      .then(v => !!v)
-      .catch(() => false);
-  }
-
-  async delete(key: string): Promise<boolean> {
-    return this.redis
-      .del(key)
-      .then(v => v > 0)
-      .catch(() => false);
-  }
-
-  async has(key: string): Promise<boolean> {
-    return this.redis
-      .exists(key)
-      .then(v => v > 0)
-      .catch(() => false);
-  }
-
-  async ttl(key: string): Promise<number> {
-    return this.redis.ttl(key).catch(() => 0);
-  }
-
-  async expire(key: string, ttl: number): Promise<boolean> {
-    return this.redis
-      .pexpire(key, ttl)
-      .then(v => v > 0)
-      .catch(() => false);
-  }
-
-  // list operations
-  async pushBack<T = unknown>(key: string, ...values: T[]): Promise<number> {
-    return this.redis
-      .rpush(key, ...values.map(v => JSON.stringify(v)))
-      .catch(() => 0);
-  }
-
-  async pushFront<T = unknown>(key: string, ...values: T[]): Promise<number> {
-    return this.redis
-      .lpush(key, ...values.map(v => JSON.stringify(v)))
-      .catch(() => 0);
-  }
-
-  async len(key: string): Promise<number> {
-    return this.redis.llen(key).catch(() => 0);
-  }
-
-  async list<T = unknown>(
-    key: string,
-    start: number,
-    end: number
-  ): Promise<T[]> {
-    return this.redis
-      .lrange(key, start, end)
-      .then(data => data.map(v => JSON.parse(v)))
-      .catch(() => []);
-  }
-
-  async popFront<T = unknown>(key: string, count: number = 1): Promise<T[]> {
-    return this.redis
-      .lpop(key, count)
-      .then(data => (data ?? []).map(v => JSON.parse(v)))
-      .catch(() => []);
-  }
-
-  async popBack<T = unknown>(key: string, count: number = 1): Promise<T[]> {
-    return this.redis
-      .rpop(key, count)
-      .then(data => (data ?? []).map(v => JSON.parse(v)))
-      .catch(() => []);
-  }
-
-  // map operations
-  async mapSet<T = unknown>(
-    map: string,
-    key: string,
-    value: T
-  ): Promise<boolean> {
-    return this.redis
-      .hset(map, key, JSON.stringify(value))
-      .then(v => v > 0)
-      .catch(() => false);
-  }
-
-  async mapIncrease(
-    map: string,
-    key: string,
-    count: number = 1
-  ): Promise<number> {
-    return this.redis.hincrby(map, key, count);
-  }
-
-  async mapDecrease(
-    map: string,
-    key: string,
-    count: number = 1
-  ): Promise<number> {
-    return this.redis.hincrby(map, key, -count);
-  }
-
-  async mapGet<T = unknown>(map: string, key: string): Promise<T | undefined> {
-    return this.redis
-      .hget(map, key)
-      .then(v => (v ? JSON.parse(v) : undefined))
-      .catch(() => undefined);
-  }
-
-  async mapDelete(map: string, key: string): Promise<boolean> {
-    return this.redis
-      .hdel(map, key)
-      .then(v => v > 0)
-      .catch(() => false);
-  }
-
-  async mapKeys(map: string): Promise<string[]> {
-    return this.redis.hkeys(map).catch(() => []);
-  }
-
-  async mapRandomKey(map: string): Promise<string | undefined> {
-    return this.redis
-      .hrandfield(map, 1)
-      .then(v =>
-        typeof v === 'string'
-          ? v
-          : Array.isArray(v)
-            ? (v[0] as string)
-            : undefined
-      )
-      .catch(() => undefined);
-  }
-
-  async mapLen(map: string): Promise<number> {
-    return this.redis.hlen(map).catch(() => 0);
-  }
-}

packages/backend/server/src/fundamentals/cache/redis/index.ts

@@ -1,38 +0,0 @@
-import { Global, Injectable, Module, OnModuleDestroy } from '@nestjs/common';
-import { Redis as IORedis } from 'ioredis';
-
-import { Config } from '../../config';
-
-class Redis extends IORedis implements OnModuleDestroy {
-  onModuleDestroy() {
-    this.disconnect();
-  }
-}
-
-@Injectable()
-export class CacheRedis extends Redis {
-  constructor(config: Config) {
-    super({ ...config.redis, db: config.redis.database });
-  }
-}
-
-@Injectable()
-export class ThrottlerRedis extends Redis {
-  constructor(config: Config) {
-    super({ ...config.redis, db: config.redis.database + 1 });
-  }
-}
-
-@Injectable()
-export class SessionRedis extends Redis {
-  constructor(config: Config) {
-    super({ ...config.redis, db: config.redis.database + 2 });
-  }
-}
-
-@Global()
-@Module({
-  providers: [CacheRedis, ThrottlerRedis, SessionRedis],
-  exports: [CacheRedis, ThrottlerRedis, SessionRedis],
-})
-export class RedisModule {}