[sync] feat: grid selection statistic chip (T3813)

Synced from teableio/teable-ee@a996401

Co-authored-by: Aries X <caoxing9@gmail.com>
Co-authored-by: Boris <boris2code@outlook.com>
Co-authored-by: Jocky-Teable <jocky@teable.ai>
Co-authored-by: Jun Lu <hammond@teable.io>
Co-authored-by: SkyHuang <sky.huang.fe@gmail.com>
Co-authored-by: Uno <uno@teable.ai>
Co-authored-by: nichenqin <nichenqin@hotmail.com>

Author: 8 people

apps/nestjs-backend/scripts/validate-dual-db-cutover.mjs

@@ -162,16 +162,24 @@ const main = async () => {
       ]);
 
     const schemaDiff = diffSets(sourceSchemas, targetSchemas);
-    const schemaTableCountDiffs = compareCountMaps(sourceSchemaTableCounts, targetSchemaTableCounts);
+    const schemaTableCountDiffs = compareCountMaps(
+      sourceSchemaTableCounts,
+      targetSchemaTableCounts
+    );
 
-    const [sourceDataCounts, targetDataCounts, sourceMetaCounts, targetMetaCounts, undoFunctionExists] =
-      await Promise.all([
-        getTableCounts(sourceClient, DATA_PLANE_TABLES),
-        getTableCounts(dataClient, DATA_PLANE_TABLES),
-        getTableCounts(sourceClient, META_PLANE_TABLES),
-        getTableCounts(metaClient, META_PLANE_TABLES),
-        getFunctionExists(dataClient, '__teable_capture_undo_row'),
-      ]);
+    const [
+      sourceDataCounts,
+      targetDataCounts,
+      sourceMetaCounts,
+      targetMetaCounts,
+      undoFunctionExists,
+    ] = await Promise.all([
+      getTableCounts(sourceClient, DATA_PLANE_TABLES),
+      getTableCounts(dataClient, DATA_PLANE_TABLES),
+      getTableCounts(sourceClient, META_PLANE_TABLES),
+      getTableCounts(metaClient, META_PLANE_TABLES),
+      getFunctionExists(dataClient, '__teable_capture_undo_row'),
+    ]);
 
     const dataCountDiffs = compareCountMaps(sourceDataCounts, targetDataCounts);
     const metaCountDiffs = compareCountMaps(sourceMetaCounts, targetMetaCounts);

apps/nestjs-backend/src/configs/threshold.config.ts

@@ -36,6 +36,7 @@ export const thresholdConfig = registerAs('threshold', () => ({
     jitter: Number(process.env.BACKEND_DB_DEADLOCK_JITTER ?? 1.0),
   },
   baseNodeMaxFolderDepth: Number(process.env.BASE_NODE_MAX_FOLDER_DEPTH ?? 2),
+  maxOwnedSpaceCount: Number(process.env.MAX_SPACE_OWNER_COUNT ?? 10),
   changeEmailSendCodeMailRate: Number(process.env.BACKEND_CHANGE_EMAIL_SEND_CODE_MAIL_RATE ?? 30),
   resetPasswordSendMailRate: Number(process.env.BACKEND_RESET_PASSWORD_SEND_MAIL_RATE ?? 30),
   signupVerificationSendCodeMailRate: Number(

apps/nestjs-backend/src/features/base/base.service.spec.ts

@@ -57,6 +57,8 @@ describe('BaseService', () => {
       return {
         service: new BaseService(
           prismaService as never,
+          {} as never,
+          {} as never,
           cls as never,
           {} as never,
           {} as never,

apps/nestjs-backend/src/features/base/base.service.ts

@@ -7,8 +7,8 @@ import {
   Role,
   generateTemplateId,
 } from '@teable/core';
-import { PrismaService, ProvisionState } from '@teable/db-main-prisma';
 import { DataPrismaService } from '@teable/db-data-prisma';
+import { PrismaService, ProvisionState } from '@teable/db-main-prisma';
 import type {
   IBaseErdVo,
   ICreateBaseFromTemplateRo,
@@ -34,6 +34,7 @@ import { IThresholdConfig, ThresholdConfig } from '../../configs/threshold.confi
 import { CustomHttpException } from '../../custom.exception';
 import { InjectDbProvider } from '../../db-provider/db.provider';
 import { IDbProvider } from '../../db-provider/db.provider.interface';
+import { DataDbClientManager } from '../../global/data-db-client-manager.service';
 import type { IClsStore } from '../../types/cls';
 import { getMaxLevelRole } from '../../utils/get-max-level-role';
 import { updateOrder } from '../../utils/update-order';
@@ -56,6 +57,7 @@ export class BaseService {
   constructor(
     private readonly prismaService: PrismaService,
     private readonly dataPrismaService: DataPrismaService,
+    private readonly dataDbClientManager: DataDbClientManager,
     private readonly cls: ClsService<IClsStore>,
     private readonly collaboratorService: CollaboratorService,
     private readonly baseDuplicateService: BaseDuplicateService,
@@ -250,8 +252,9 @@ export class BaseService {
     try {
       const sqlList = this.dbProvider.createSchema(base.id);
       if (sqlList) {
+        const dataPrisma = await this.dataDbClientManager.dataPrismaForSpace(spaceId);
         for (const sql of sqlList) {
-          await this.dataPrismaService.$executeRawUnsafe(sql);
+          await dataPrisma.$executeRawUnsafe(sql);
         }
       }
 

apps/nestjs-backend/src/features/collaborator/collaborator.service.ts

@@ -22,6 +22,7 @@ import { Knex } from 'knex';
 import { difference, keyBy, map } from 'lodash';
 import { InjectModel } from 'nest-knexjs';
 import { ClsService } from 'nestjs-cls';
+import { ThresholdConfig, IThresholdConfig } from '../../configs/threshold.config';
 import { CustomHttpException } from '../../custom.exception';
 import { InjectDbProvider } from '../../db-provider/db.provider';
 import { IDbProvider } from '../../db-provider/db.provider.interface';
@@ -43,7 +44,8 @@ export class CollaboratorService {
     private readonly cls: ClsService<IClsStore>,
     private readonly eventEmitterService: EventEmitterService,
     @InjectModel('CUSTOM_KNEX') private readonly knex: Knex,
-    @InjectDbProvider() private readonly dbProvider: IDbProvider
+    @InjectDbProvider() private readonly dbProvider: IDbProvider,
+    @ThresholdConfig() private readonly thresholdConfig: IThresholdConfig
   ) {}
 
   async createSpaceCollaborator({
@@ -82,6 +84,20 @@ export class CollaboratorService {
         }
       );
     }
+    if (role === Role.Owner) {
+      const userIds = collaborators
+        .filter((c) => c.principalType === PrincipalType.User)
+        .map((c) => c.principalId);
+      if (userIds.length > 0) {
+        const countMap = await this.countUserOwnedSpaces(userIds);
+        for (const uid of userIds) {
+          await this.validateOwnedSpaceLimit(
+            countMap.get(uid) ?? 0,
+            uid !== currentUserId ? uid : undefined
+          );
+        }
+      }
+    }
     // if has exist base collaborator, then delete it
     const bases = await this.prismaService.txClient().base.findMany({
       where: {
@@ -548,6 +564,61 @@ export class CollaboratorService {
     return collaborators.length === 1 && collaborators[0].principal_id === userId;
   }
 
+  async countUserOwnedSpaces(userId: string): Promise<number>;
+  async countUserOwnedSpaces(userIds: string[]): Promise<Map<string, number>>;
+  async countUserOwnedSpaces(
+    userIdOrIds: string | string[]
+  ): Promise<number | Map<string, number>> {
+    const isSingle = typeof userIdOrIds === 'string';
+    const userIds = isSingle ? [userIdOrIds] : userIdOrIds;
+    if (userIds.length === 0) return isSingle ? 0 : new Map();
+    const builder = this.knex('collaborator')
+      .join('space', 'collaborator.resource_id', 'space.id')
+      .whereIn('collaborator.principal_id', userIds)
+      .where('collaborator.principal_type', PrincipalType.User)
+      .where('collaborator.resource_type', CollaboratorType.Space)
+      .where('collaborator.role_name', Role.Owner)
+      .whereNull('space.deleted_time')
+      .groupBy('collaborator.principal_id')
+      .select('collaborator.principal_id as user_id')
+      .count('* as count');
+    const result = await this.prismaService
+      .txClient()
+      .$queryRawUnsafe<{ user_id: string; count: number }[]>(builder.toQuery());
+    if (isSingle) {
+      return Number(result[0]?.count ?? 0);
+    }
+    const countMap = new Map<string, number>();
+    for (const row of result) {
+      countMap.set(row.user_id, Number(row.count));
+    }
+    return countMap;
+  }
+
+  async validateOwnedSpaceLimit(currentCount: number, userId?: string): Promise<void> {
+    const maxCount = this.thresholdConfig.maxOwnedSpaceCount;
+    if (maxCount <= 0 || currentCount < maxCount) return;
+
+    const userName = userId
+      ? await this.prismaService.user
+          .findUnique({ where: { id: userId }, select: { name: true, email: true } })
+          .then((user) => (user ? `${user.name} (${user.email})` : undefined))
+      : undefined;
+
+    throw new CustomHttpException(
+      `Owned space limit exceeded, max: ${maxCount}${userName ? `, user: ${userName}` : ''}`,
+      HttpErrorCode.VALIDATION_ERROR,
+      {
+        localization: {
+          i18nKey: userId
+            ? 'httpErrors.space.ownedSpaceLimitExceededOther'
+            : 'httpErrors.space.ownedSpaceLimitExceeded',
+          context: userId ? { max: maxCount, name: userName } : { max: maxCount },
+        },
+      }
+    );
+  }
+
   async deleteCollaborator({
     resourceId,
     resourceType,
@@ -659,6 +730,19 @@ export class CollaboratorService {
       );
     }
 
+    if (
+      role === Role.Owner &&
+      resourceType === CollaboratorType.Space &&
+      targetColl.roleName !== Role.Owner &&
+      principalType === PrincipalType.User
+    ) {
+      const count = await this.countUserOwnedSpaces(principalId);
+      await this.validateOwnedSpaceLimit(
+        count,
+        principalId !== currentUserId ? principalId : undefined
+      );
+    }
+
     const res = await this.prismaService.txClient().collaborator.updateMany({
       where: {
         resourceId: resourceId,

apps/nestjs-backend/src/features/integrity/foreign-key.service.ts

@@ -88,8 +88,9 @@ export class ForeignKeyIntegrityService {
       .toQuery();
 
     try {
-      const invalidRefs =
-        await this.dataPrismaService.txClient().$queryRawUnsafe<{ count: bigint }[]>(invalidQuery);
+      const invalidRefs = await this.dataPrismaService
+        .txClient()
+        .$queryRawUnsafe<{ count: bigint }[]>(invalidQuery);
       const refCount = Number(invalidRefs[0]?.count || 0);
 
       if (refCount > 0) {

apps/nestjs-backend/src/features/integrity/link-integrity.service.ts

@@ -348,10 +348,9 @@ export class LinkIntegrityService {
 
       let canCheckLinks = false;
       const tableExistsSql = this.dbProvider.checkTableExist(options.fkHostTableName);
-      const tableExists =
-        await this.dataPrismaService.txClient().$queryRawUnsafe<{ exists: boolean }[]>(
-          tableExistsSql
-        );
+      const tableExists = await this.dataPrismaService
+        .txClient()
+        .$queryRawUnsafe<{ exists: boolean }[]>(tableExistsSql);
       const hostTableExists = tableExists[0].exists;
 
       if (!hostTableExists) {
@@ -538,11 +537,7 @@ export class LinkIntegrityService {
 
     if (hostAlreadyExists) {
       const [selfKeyExists, foreignKeyExists, orderColumnExists] = await Promise.all([
-        this.dbProvider.checkColumnExist(
-          options.fkHostTableName,
-          options.selfKeyName,
-          dataPrisma
-        ),
+        this.dbProvider.checkColumnExist(options.fkHostTableName, options.selfKeyName, dataPrisma),
         this.dbProvider.checkColumnExist(
           options.fkHostTableName,
           options.foreignKeyName,

apps/nestjs-backend/src/features/oauth/oauth.service.ts

@@ -333,7 +333,11 @@ export class OAuthService {
         homepage: c.homepage,
         scopes: c.scopes,
         lastUsedTime: lastUsedTimeMap[c.clientId]?.lastUsedTime,
-        createdUser: userMap[c.createdBy],
+        createdUser:
+          userMap[c.createdBy] ??
+          (c.createdBy === 'system'
+            ? { name: 'System', email: 'system@teable.ai' }
+            : { name: 'Unknown', email: '' }),
       })
     );
   }

apps/nestjs-backend/src/features/record/computed/services/computed-dependency-collector.service.ts

@@ -152,9 +152,9 @@ export class ComputedDependencyCollectorService {
   ): Promise<string[]> {
     const dbTable = await this.getDbTableName(tableId, ctx);
     const { schema, table } = this.splitDbTableName(dbTable);
-    const qb = (schema ? this.dataKnex.withSchema(schema) : this.dataKnex).select('__id').from(
-      table
-    );
+    const qb = (schema ? this.dataKnex.withSchema(schema) : this.dataKnex)
+      .select('__id')
+      .from(table);
     const rows = await this.dataPrismaService
       .txClient()
       .$queryRawUnsafe<Array<{ __id: string }>>(qb.toQuery());

apps/nestjs-backend/src/features/record/record.service.ts

@@ -2226,10 +2226,9 @@ export class RecordService {
 
     this.logger.debug('getSearchHitIndex query: %s', searchQuery);
 
-    const result =
-      await this.dataPrismaService
-        .txClient()
-        .$queryRawUnsafe<{ __id: string; fieldId: string }[]>(searchQuery);
+    const result = await this.dataPrismaService
+      .txClient()
+      .$queryRawUnsafe<{ __id: string; fieldId: string }[]>(searchQuery);
 
     if (!result.length) {
       return null;
@@ -2600,7 +2599,9 @@ export class RecordService {
     const rowCountSql = qb.count({ count: '*' });
     const sql = rowCountSql.toQuery();
     this.logger.debug('getRowCountSql: %s', sql);
-    const result = await this.dataPrismaService.txClient().$queryRawUnsafe<{ count?: number }[]>(sql);
+    const result = await this.dataPrismaService
+      .txClient()
+      .$queryRawUnsafe<{ count?: number }[]>(sql);
     return Number(result[0].count);
   }
 
@@ -2710,10 +2711,9 @@ export class RecordService {
     );
 
     try {
-      const result =
-        await this.dataPrismaService.txClient().$queryRawUnsafe<{ [key: string]: unknown; __c: number }[]>(
-          groupSql
-        );
+      const result = await this.dataPrismaService
+        .txClient()
+        .$queryRawUnsafe<{ [key: string]: unknown; __c: number }[]>(groupSql);
       const pointsResult = await this.groupDbCollection2GroupPoints(
         result,
         groupFields,