fix: field unique index finder and add UniqueIndexService for index check (#1670)

younocode · web-flow · commit 9c0aaf5ca325 · 2025-07-16T17:41:13.000+08:00
* feat: enhanced FieldService find unique indexes and add UniqueIndexService for index check

* feat: enhance index retrieval in FieldService and update Integrity component for better display

* refactor: simplify findUniqueIndexesForField method by removing fieldId parameter

* feat: enhance index retrieval in Postgres provider

* feat: update index retrieval in SQLite provider and FieldService for consistency with Postgres
diff --git a/apps/nestjs-backend/src/db-provider/postgres.provider.ts b/apps/nestjs-backend/src/db-provider/postgres.provider.ts
@@ -555,9 +555,28 @@ WHERE tc.constraint_type = 'FOREIGN KEY'
     return this.knex
       .raw(
         `
-        SELECT indexname as name
-        FROM pg_indexes
-        WHERE tablename = ?
+        SELECT
+    i.relname AS name,
+    ix.indisunique AS "isUnique",
+    CAST(jsonb_agg(a.attname ORDER BY u.attposition) AS TEXT) AS columns
+FROM
+    pg_class t,
+    pg_class i,
+    pg_index ix,
+    pg_attribute a,
+    unnest(ix.indkey) WITH ORDINALITY u(attnum, attposition)
+WHERE
+    t.oid = ix.indrelid
+    AND i.oid = ix.indexrelid
+    AND a.attrelid = t.oid
+    AND a.attnum = u.attnum
+    AND t.relname = ?
+GROUP BY
+    i.relname,
+    ix.indisunique,
+    ix.indisprimary
+ORDER BY
+    i.relname;
       `,
         [tableName]
       )
diff --git a/apps/nestjs-backend/src/db-provider/sqlite.provider.ts b/apps/nestjs-backend/src/db-provider/sqlite.provider.ts
@@ -487,6 +487,21 @@ export class SqliteProvider implements IDbProvider {
   }
 
   getTableIndexes(dbTableName: string): string {
-    return this.knex.raw(`PRAGMA index_list(??)`, [dbTableName]).toQuery();
+    return this.knex
+      .raw(
+        `SELECT
+    s.name AS name,
+    (SELECT "unique" FROM pragma_index_list(s.tbl_name) WHERE name = s.name) AS isUnique,
+    (SELECT json_group_array(name) FROM pragma_index_info(s.name) ORDER BY seqno) AS columns
+FROM
+    sqlite_schema AS s
+WHERE
+    s.type = 'index'
+    AND s.tbl_name = ?
+ORDER BY
+    s.name;`,
+        [dbTableName]
+      )
+      .toQuery();
   }
 }
diff --git a/apps/nestjs-backend/src/features/field/field-calculate/field-converting.service.ts b/apps/nestjs-backend/src/features/field/field-calculate/field-converting.service.ts
@@ -1214,8 +1214,7 @@ export class FieldConvertingService {
 
     const matchedIndexes = await this.fieldService.findUniqueIndexesForField(
       dbTableName,
-      dbFieldName,
-      oldField.id
+      dbFieldName
     );
 
     const fieldValidationQuery = this.knex.schema
diff --git a/apps/nestjs-backend/src/features/field/field.service.ts b/apps/nestjs-backend/src/features/field/field.service.ts
@@ -373,17 +373,18 @@ export class FieldService implements IReadonlyAdapterService {
     });
   }
 
-  async findUniqueIndexesForField(dbTableName: string, dbFieldName: string, fieldId: string) {
+  async findUniqueIndexesForField(dbTableName: string, dbFieldName: string) {
     const indexesQuery = this.dbProvider.getTableIndexes(dbTableName);
     const indexes = await this.prismaService
       .txClient()
-      .$queryRawUnsafe<{ name: string }[]>(indexesQuery);
+      .$queryRawUnsafe<{ name: string; columns: string; isUnique: boolean }[]>(indexesQuery);
+
     return indexes
-      .filter(
-        (index) =>
-          index.name.includes(`${dbFieldName.toLowerCase()}_unique`) ||
-          index.name.includes(`${fieldId.toLowerCase()}_unique`)
-      )
+      .filter((index) => {
+        const { columns, isUnique } = index;
+        const columnsArray = JSON.parse(columns) as string[];
+        return isUnique && columnsArray.includes(dbFieldName);
+      })
       .map((index) => index.name);
   }
 
@@ -410,7 +411,7 @@ export class FieldService implements IReadonlyAdapterService {
     }
 
     const dbTableName = table.dbTableName;
-    const matchedIndexes = await this.findUniqueIndexesForField(dbTableName, dbFieldName, fieldId);
+    const matchedIndexes = await this.findUniqueIndexesForField(dbTableName, dbFieldName);
 
     const fieldValidationSqls = this.knex.schema
       .alterTable(dbTableName, (table) => {
diff --git a/apps/nestjs-backend/src/features/integrity/integrity.module.ts b/apps/nestjs-backend/src/features/integrity/integrity.module.ts
@@ -1,12 +1,20 @@
 import { Module } from '@nestjs/common';
+import { FieldModule } from '../field/field.module';
 import { ForeignKeyIntegrityService } from './foreign-key.service';
 import { IntegrityController } from './integrity.controller';
 import { LinkFieldIntegrityService } from './link-field.service';
 import { LinkIntegrityService } from './link-integrity.service';
+import { UniqueIndexService } from './unique-index.service';
 
 @Module({
+  imports: [FieldModule],
   controllers: [IntegrityController],
-  providers: [ForeignKeyIntegrityService, LinkFieldIntegrityService, LinkIntegrityService],
+  providers: [
+    ForeignKeyIntegrityService,
+    LinkFieldIntegrityService,
+    LinkIntegrityService,
+    UniqueIndexService,
+  ],
   exports: [LinkIntegrityService],
 })
 export class IntegrityModule {}
diff --git a/apps/nestjs-backend/src/features/integrity/link-integrity.service.ts b/apps/nestjs-backend/src/features/integrity/link-integrity.service.ts
@@ -9,6 +9,7 @@ import { createFieldInstanceByRaw } from '../field/model/factory';
 import type { LinkFieldDto } from '../field/model/field-dto/link-field.dto';
 import { ForeignKeyIntegrityService } from './foreign-key.service';
 import { LinkFieldIntegrityService } from './link-field.service';
+import { UniqueIndexService } from './unique-index.service';
 
 @Injectable()
 export class LinkIntegrityService {
@@ -18,6 +19,7 @@ export class LinkIntegrityService {
     private readonly prismaService: PrismaService,
     private readonly foreignKeyIntegrityService: ForeignKeyIntegrityService,
     private readonly linkFieldIntegrityService: LinkFieldIntegrityService,
+    private readonly uniqueIndexService: UniqueIndexService,
     @InjectDbProvider() private readonly dbProvider: IDbProvider
   ) {}
 
@@ -32,6 +34,7 @@ export class LinkIntegrityService {
       select: {
         id: true,
         name: true,
+        dbTableName: true,
         fields: {
           where: { type: FieldType.Link, isLookup: null, deletedTime: null },
         },
@@ -57,6 +60,16 @@ export class LinkIntegrityService {
           issues: tableIssues,
         });
       }
+      const uniqueIndexIssues = await this.uniqueIndexService.checkUniqueIndex(table);
+      if (uniqueIndexIssues.length > 0) {
+        linkFieldIssues.push({
+          baseId: mainBase.id,
+          baseName: mainBase.name,
+          tableId: table.id,
+          tableName: table.name,
+          issues: uniqueIndexIssues,
+        });
+      }
     }
 
     for (const field of crossBaseLinkFields) {
@@ -299,6 +312,14 @@ export class LinkIntegrityService {
             result && fixResults.push(result);
             break;
           }
+          case IntegrityIssueType.UniqueIndexNotFound: {
+            const result = await this.uniqueIndexService.fixUniqueIndex(
+              issues.tableId,
+              issue.fieldId
+            );
+            result && fixResults.push(result);
+            break;
+          }
           default:
             break;
         }
diff --git a/apps/nestjs-backend/src/features/integrity/unique-index.service.ts b/apps/nestjs-backend/src/features/integrity/unique-index.service.ts
@@ -0,0 +1,109 @@
+import { Injectable } from '@nestjs/common';
+import { IdPrefix } from '@teable/core';
+import { PrismaService } from '@teable/db-main-prisma';
+import { IntegrityIssueType, type IIntegrityIssue } from '@teable/openapi';
+import { Knex } from 'knex';
+import { InjectModel } from 'nest-knexjs';
+import { InjectDbProvider } from '../../db-provider/db.provider';
+import { IDbProvider } from '../../db-provider/db.provider.interface';
+import { FieldService } from '../field/field.service';
+
+@Injectable()
+export class UniqueIndexService {
+  constructor(
+    private readonly prismaService: PrismaService,
+    @InjectModel('CUSTOM_KNEX') private readonly knex: Knex,
+    @InjectDbProvider() private readonly dbProvider: IDbProvider,
+    private readonly fieldService: FieldService
+  ) {}
+
+  async checkUniqueIndex(table: {
+    id: string;
+    name: string;
+    dbTableName: string;
+  }): Promise<IIntegrityIssue[]> {
+    const issues: IIntegrityIssue[] = [];
+
+    const colId = '__id';
+    const idUniqueIndexExists =
+      (await this.fieldService.findUniqueIndexesForField(table.dbTableName, colId)).length > 0;
+
+    if (!idUniqueIndexExists) {
+      issues.push({
+        fieldId: colId,
+        type: IntegrityIssueType.UniqueIndexNotFound,
+        message: `Unique index ${colId} not found for table ${table.name}`,
+      });
+    }
+
+    const uniqueFields = await this.prismaService.field.findMany({
+      where: { tableId: table.id, deletedTime: null, unique: true },
+      select: { id: true, dbFieldName: true },
+    });
+
+    for (const field of uniqueFields) {
+      const indexNames = await this.fieldService.findUniqueIndexesForField(
+        table.dbTableName,
+        field.dbFieldName
+      );
+      if (indexNames.length === 0) {
+        issues.push({
+          fieldId: field.id,
+          type: IntegrityIssueType.UniqueIndexNotFound,
+          message: `Unique index ${field.id} not found for table ${table.name}`,
+        });
+      }
+    }
+    return issues;
+  }
+
+  async fixUniqueIndex(tableId?: string, fieldId?: string): Promise<IIntegrityIssue | undefined> {
+    if (!tableId || !fieldId) {
+      return;
+    }
+
+    const table = await this.prismaService.tableMeta.findFirstOrThrow({
+      where: { id: tableId, deletedTime: null },
+      select: { dbTableName: true, name: true },
+    });
+
+    let sql: string | undefined;
+    if (fieldId.startsWith('__')) {
+      sql = this.knex.schema
+        .alterTable(table.dbTableName, (table) => {
+          table.unique([fieldId]);
+        })
+        .toQuery();
+    } else if (fieldId.startsWith(IdPrefix.Field)) {
+      const field = await this.prismaService.field.findFirstOrThrow({
+        where: { id: fieldId, deletedTime: null },
+        select: { dbFieldName: true },
+      });
+
+      const indexName = this.fieldService.getFieldUniqueKeyName(
+        table.dbTableName,
+        field.dbFieldName,
+        fieldId
+      );
+
+      sql = this.knex.schema
+        .alterTable(table.dbTableName, (table) => {
+          table.unique([field.dbFieldName], {
+            indexName,
+          });
+        })
+        .toQuery();
+    }
+
+    if (!sql) {
+      return;
+    }
+    await this.prismaService.txClient().$executeRawUnsafe(sql);
+
+    return {
+      type: IntegrityIssueType.UniqueIndexNotFound,
+      fieldId,
+      message: `Unique index ${fieldId} fixed for table ${table.name}`,
+    };
+  }
+}
diff --git a/apps/nestjs-backend/test/field-converting.e2e-spec.ts b/apps/nestjs-backend/test/field-converting.e2e-spec.ts
@@ -31,8 +31,10 @@ import {
 } from '@teable/core';
 import { PrismaService } from '@teable/db-main-prisma';
 import { type ITableFullVo } from '@teable/openapi';
+import type { Knex } from 'knex';
 import { DB_PROVIDER_SYMBOL } from '../src/db-provider/db.provider';
 import type { IDbProvider } from '../src/db-provider/db.provider.interface';
+import { FieldService } from '../src/features/field/field.service';
 import {
   getRecords,
   createField,
@@ -56,12 +58,16 @@ describe('OpenAPI Freely perform column transformations (e2e)', () => {
   const baseId = globalThis.testConfig.baseId;
   let dbProvider: IDbProvider;
   let prisma: PrismaService;
+  let fieldService: FieldService;
+  let knex: Knex;
 
   beforeAll(async () => {
     const appCtx = await initApp();
     app = appCtx.app;
     dbProvider = appCtx.app.get<IDbProvider>(DB_PROVIDER_SYMBOL);
     prisma = appCtx.app.get<PrismaService>(PrismaService);
+    fieldService = appCtx.app.get<FieldService>(FieldService);
+    knex = appCtx.app.get('CUSTOM_KNEX');
   });
 
   afterAll(async () => {
@@ -4010,4 +4016,69 @@ describe('OpenAPI Freely perform column transformations (e2e)', () => {
       ]);
     });
   });
+
+  describe('modify primary field', () => {
+    bfAf();
+
+    it('should modify general property', async () => {
+      const primaryField = table1.fields[0];
+      const primaryFieldId = primaryField.id;
+      const newFieldRo: IFieldRo = {
+        ...primaryField,
+        dbFieldName: 'id',
+      };
+
+      const field = await convertField(table1.id, primaryField.id, newFieldRo);
+      expect(field.dbFieldName).toEqual('id');
+
+      const uniqueFieldRo: IFieldRo = {
+        ...field,
+        unique: true,
+      };
+
+      const uniqueField = await convertField(table1.id, primaryFieldId, uniqueFieldRo);
+      expect(uniqueField.unique).toEqual(true);
+      const matchedIndexes1 = await fieldService.findUniqueIndexesForField(
+        table1.dbTableName,
+        uniqueField.dbFieldName
+      );
+      expect(matchedIndexes1).toHaveLength(1);
+
+      const dropUniqueFieldRo: IFieldRo = {
+        ...uniqueField,
+        unique: false,
+      };
+
+      const dropUniqueField = await convertField(table1.id, primaryFieldId, dropUniqueFieldRo);
+      expect(dropUniqueField.unique).toEqual(false);
+      const matchedIndexes2 = await fieldService.findUniqueIndexesForField(
+        table1.dbTableName,
+        dropUniqueField.dbFieldName
+      );
+      expect(matchedIndexes2).toHaveLength(0);
+    });
+
+    it('should modify old unique property', async () => {
+      const field = table1.fields[0];
+      const matchedIndexes = await fieldService.findUniqueIndexesForField(
+        table1.dbTableName,
+        field.dbFieldName
+      );
+      expect(matchedIndexes).toHaveLength(0);
+
+      const sql = knex.schema
+        .alterTable(table1.dbTableName, (table) => {
+          table.unique([field.dbFieldName], {});
+        })
+        .toQuery();
+
+      await prisma.txClient().$executeRawUnsafe(sql);
+
+      const matchedIndexes1 = await fieldService.findUniqueIndexesForField(
+        table1.dbTableName,
+        field.dbFieldName
+      );
+      expect(matchedIndexes1).toHaveLength(1);
+    });
+  });
 });
diff --git a/apps/nestjs-backend/test/integrity.e2e-spec.ts b/apps/nestjs-backend/test/integrity.e2e-spec.ts
diff --git a/apps/nextjs-app/src/features/app/blocks/design/components/Integrity.tsx b/apps/nextjs-app/src/features/app/blocks/design/components/Integrity.tsx
diff --git a/packages/openapi/src/integrity/link-check.ts b/packages/openapi/src/integrity/link-check.ts
