chore: add dbFieldName dbTableName to domain

Author: nichenqin

.dockerignore

@@ -45,8 +45,10 @@ tmp
 
 # other
 **/db
+!packages/v2/adapter-postgres-state/src/db
+!packages/v2/adapter-postgres-state/src/db/**
 **/.assets
 **/.temporary
 **.DS_Store
 docs
-**/*.md
+**/*.md

agents.md

@@ -90,6 +90,7 @@ Practical exceptions that are required by the architecture:
 - `neverthrow` error side uses strings (e.g. `Result<T, string>`).
 - The Specification interface requires `isSatisfiedBy(...): boolean`.
 - Value Objects may expose `toString()` / `toDate()` / `toNumber()` for adapter/serialization boundaries (avoid using these in domain logic).
+- Rehydration-only Value Objects (e.g. `DbTableName`, `DbFieldName`) must extend `RehydratedValueObject`; create empty placeholders in domain, set real values only via repository rehydrate, and return `err(...)` when accessed before rehydrate.
 
 ## Builders/factories (non-negotiable)
 

apps/nestjs-backend/tsconfig.json

@@ -8,7 +8,7 @@
     "moduleResolution": "Node16",
     "declaration": true,
     "declarationDir": "./dist",
-    "module": "CommonJS",
+    "module": "Node16",
     "noEmit": false,
     "sourceMap": true,
     "allowJs": false,

packages/v2/adapter-postgres-ddl/src/naming.ts

@@ -29,14 +29,6 @@ export const joinDbTableName = (schemaName: string, tableName: string): string =
   return `${schemaName}.${tableName}`;
 };
 
-export const splitDbTableName = (
-  dbTableName: string
-): { schema: string | null; tableName: string } => {
-  const dotIndex = dbTableName.indexOf('.');
-  if (dotIndex === -1) return { schema: null, tableName: dbTableName };
-  return { schema: dbTableName.slice(0, dotIndex), tableName: dbTableName.slice(dotIndex + 1) };
-};
-
 export const ensureUniqueDbFieldName = (baseName: string, reservedNames: Set<string>): string => {
   if (!reservedNames.has(baseName)) return baseName;
 
@@ -49,19 +41,3 @@ export const ensureUniqueDbFieldName = (baseName: string, reservedNames: Set<str
 
   return candidate;
 };
-
-export const buildDbFieldNameMap = (
-  fields: ReadonlyArray<{ id: string; name: string }>
-): Map<string, string> => {
-  const reservedNames = new Set(baseRecordColumnNames);
-  const fieldDbNameById = new Map<string, string>();
-
-  for (const field of fields) {
-    const baseName = convertNameToValidCharacter(field.name, 40);
-    const dbFieldName = ensureUniqueDbFieldName(baseName, reservedNames);
-    reservedNames.add(dbFieldName);
-    fieldDbNameById.set(field.id, dbFieldName);
-  }
-
-  return fieldDbNameById;
-};

packages/v2/adapter-postgres-ddl/src/repositories/PostgresTableSchemaRepository.spec.ts

@@ -1,8 +1,11 @@
+/* eslint-disable sonarjs/cognitive-complexity */
 /* eslint-disable @typescript-eslint/naming-convention */
 import type { IExecutionContext, ITableSchemaRepository } from '@teable/v2-core';
 import {
   ActorId,
   BaseId,
+  DbFieldName,
+  DbTableName,
   FieldName,
   RatingMax,
   SelectOption,
@@ -22,21 +25,11 @@ type StartedPostgreSqlContainer = Awaited<ReturnType<PostgreSqlContainer['start'
 import { registerV2PostgresDdlAdapter } from '../di/register';
 import {
   baseRecordColumnNames,
-  buildDbFieldNameMap,
   convertNameToValidCharacter,
+  ensureUniqueDbFieldName,
   joinDbTableName,
-  splitDbTableName,
 } from '../naming';
 
-interface ITestTableMetaTable {
-  id: string;
-  db_table_name: string;
-}
-
-interface ITestDatabase {
-  table_meta: ITestTableMetaTable;
-}
-
 describe('PostgresTableSchemaRepository (pg)', () => {
   let pgContainer: StartedPostgreSqlContainer;
 
@@ -58,7 +51,7 @@ describe('PostgresTableSchemaRepository (pg)', () => {
       pg: { connectionString: pgContainer.getConnectionUri() },
     });
 
-    const db = c.resolve<Kysely<ITestDatabase>>(v2PostgresDbTokens.db);
+    const db = c.resolve<Kysely<unknown>>(v2PostgresDbTokens.db);
     const repo = c.resolve<ITableSchemaRepository>(v2CoreTokens.tableSchemaRepository);
 
     try {
@@ -109,23 +102,28 @@ describe('PostgresTableSchemaRepository (pg)', () => {
         baseId.toString(),
         convertNameToValidCharacter(table.name().toString(), 40)
       );
-      const fieldDbNameById = buildDbFieldNameMap(
-        table
-          .fields()
-          .map((field) => ({ id: field.id().toString(), name: field.name().toString() }))
-      );
-
-      await db.schema
-        .createTable('table_meta')
-        .ifNotExists()
-        .addColumn('id', 'text', (col) => col.primaryKey())
-        .addColumn('db_table_name', 'text', (col) => col.notNull())
-        .execute();
-
-      await db
-        .insertInto('table_meta')
-        .values({ id: table.id().toString(), db_table_name: dbTableName })
-        .execute();
+      const reservedNames = new Set(baseRecordColumnNames);
+      const fieldDbNames: string[] = [];
+
+      const dbTableNameResult = DbTableName.rehydrate(dbTableName);
+      expect(dbTableNameResult.isOk()).toBe(true);
+      if (dbTableNameResult.isErr()) return;
+      const setTableDbNameResult = table.setDbTableName(dbTableNameResult.value);
+      expect(setTableDbNameResult.isOk()).toBe(true);
+      if (setTableDbNameResult.isErr()) return;
+
+      for (const field of table.fields()) {
+        const baseName = convertNameToValidCharacter(field.name().toString(), 40);
+        const dbFieldName = ensureUniqueDbFieldName(baseName, reservedNames);
+        reservedNames.add(dbFieldName);
+        fieldDbNames.push(dbFieldName);
+        const dbFieldNameResult = DbFieldName.rehydrate(dbFieldName);
+        expect(dbFieldNameResult.isOk()).toBe(true);
+        if (dbFieldNameResult.isErr()) return;
+        const setFieldDbNameResult = field.setDbFieldName(dbFieldNameResult.value);
+        expect(setFieldDbNameResult.isOk()).toBe(true);
+        if (setFieldDbNameResult.isErr()) return;
+      }
 
       const actorIdResult = ActorId.create('system');
       expect(actorIdResult.isOk()).toBe(true);
@@ -137,9 +135,12 @@ describe('PostgresTableSchemaRepository (pg)', () => {
       if (insertResult.isErr()) return;
 
       const expectedBaseColumns = baseRecordColumnNames;
-      const expectedFieldColumns = [...fieldDbNameById.values()];
+      const expectedFieldColumns = fieldDbNames;
 
-      const { schema, tableName } = splitDbTableName(dbTableName);
+      const splitResult = dbTableNameResult.value.split({ defaultSchema: 'public' });
+      expect(splitResult.isOk()).toBe(true);
+      if (splitResult.isErr()) return;
+      const { schema, tableName } = splitResult.value;
       const schemaName = schema ?? 'public';
       const columnsResult = await sql<{ columnName: string }>`
         select column_name as "columnName"

packages/v2/adapter-postgres-ddl/src/repositories/PostgresTableSchemaRepository.ts

@@ -11,7 +11,6 @@ import { sql } from 'kysely';
 import { err, ok } from 'neverthrow';
 import type { Result } from 'neverthrow';
 
-import { buildDbFieldNameMap, splitDbTableName } from '../naming';
 import {
   PostgresTableFieldVisitor,
   type ICreateTableBuilderRef,
@@ -26,27 +25,12 @@ export class PostgresTableSchemaRepository implements ITableSchemaRepository {
 
   @TraceSpan()
   async insert(context: IExecutionContext, table: Table): Promise<Result<void, string>> {
-    const tableId = table.id().toString();
-    let dbTableName: string;
-    const fieldDbNameById = buildDbFieldNameMap(
-      table.fields().map((field) => ({ id: field.id().toString(), name: field.name().toString() }))
-    );
+    const dbTableNameResult = table
+      .dbTableName()
+      .andThen((name) => name.split({ defaultSchema: null }));
+    if (dbTableNameResult.isErr()) return err(dbTableNameResult.error);
+    const { schema, tableName } = dbTableNameResult.value;
     const db = resolvePostgresDb(this.db, context);
-    try {
-      const tableMetaResult = await sql<{ dbTableName: string }>`
-        select db_table_name as "dbTableName"
-        from table_meta
-        where id = ${tableId}
-      `.execute(db);
-
-      dbTableName = tableMetaResult.rows[0]?.dbTableName ?? '';
-    } catch (error) {
-      return err(`Failed to load table metadata: ${describeError(error)}`);
-    }
-
-    if (!dbTableName) return err('Missing db table name');
-
-    const { schema, tableName } = splitDbTableName(dbTableName);
 
     type ICreateTableBuilder = CreateTableBuilder<string, string>;
     const schemaBuilder = schema ? db.schema.withSchema(schema) : db.schema;
@@ -64,7 +48,7 @@ export class PostgresTableSchemaRepository implements ITableSchemaRepository {
       .addColumn('__version', 'integer', (col: ColumnDefinitionBuilder) => col.notNull());
 
     const builderRef: ICreateTableBuilderRef = { builder };
-    const visitor = new PostgresTableFieldVisitor(builderRef, fieldDbNameById);
+    const visitor = new PostgresTableFieldVisitor(builderRef);
     const applyResult = visitor.apply(table);
     if (applyResult.isErr()) return err(applyResult.error);
 

packages/v2/adapter-postgres-ddl/src/visitors/PostgresTableFieldVisitor.ts

@@ -26,10 +26,7 @@ export interface ICreateTableBuilderRef {
 }
 
 export class PostgresTableFieldVisitor implements IFieldVisitor<void> {
-  constructor(
-    private readonly builderRef: ICreateTableBuilderRef,
-    private readonly fieldDbNameById: Map<string, string>
-  ) {}
+  constructor(private readonly builderRef: ICreateTableBuilderRef) {}
 
   private static isFieldArray(value: Table | ReadonlyArray<Field>): value is ReadonlyArray<Field> {
     return Array.isArray(value);
@@ -51,52 +48,57 @@ export class PostgresTableFieldVisitor implements IFieldVisitor<void> {
   }
 
   visitSingleLineTextField(field: SingleLineTextField): Result<void, string> {
-    return this.addColumn(field.id().toString(), 'text');
+    return this.addColumn(field, 'text');
   }
 
   visitLongTextField(field: LongTextField): Result<void, string> {
-    return this.addColumn(field.id().toString(), 'text');
+    return this.addColumn(field, 'text');
   }
 
   visitNumberField(field: NumberField): Result<void, string> {
-    return this.addColumn(field.id().toString(), 'numeric');
+    return this.addColumn(field, 'numeric');
   }
 
   visitRatingField(field: RatingField): Result<void, string> {
-    return this.addColumn(field.id().toString(), 'numeric');
+    return this.addColumn(field, 'numeric');
   }
 
   visitSingleSelectField(field: SingleSelectField): Result<void, string> {
-    return this.addColumn(field.id().toString(), 'text');
+    return this.addColumn(field, 'text');
   }
 
   visitMultipleSelectField(field: MultipleSelectField): Result<void, string> {
-    return this.addColumn(field.id().toString(), 'jsonb');
+    return this.addColumn(field, 'jsonb');
   }
 
   visitCheckboxField(field: CheckboxField): Result<void, string> {
-    return this.addColumn(field.id().toString(), 'boolean');
+    return this.addColumn(field, 'boolean');
   }
 
   visitAttachmentField(field: AttachmentField): Result<void, string> {
-    return this.addColumn(field.id().toString(), 'jsonb');
+    return this.addColumn(field, 'jsonb');
   }
 
   visitDateField(field: DateField): Result<void, string> {
-    return this.addColumn(field.id().toString(), 'timestamptz');
+    return this.addColumn(field, 'timestamptz');
   }
 
   visitUserField(field: UserField): Result<void, string> {
-    return this.addColumn(field.id().toString(), 'jsonb');
+    return this.addColumn(field, 'jsonb');
   }
 
   visitButtonField(field: ButtonField): Result<void, string> {
-    return this.addColumn(field.id().toString(), 'jsonb');
+    return this.addColumn(field, 'jsonb');
   }
 
-  private addColumn(fieldId: string, dataType: ITableColumnDataType): Result<void, string> {
-    const columnName = this.fieldDbNameById.get(fieldId);
-    if (!columnName) return err(`Missing db field name for field ${fieldId}`);
+  private addColumn(field: Field, dataType: ITableColumnDataType): Result<void, string> {
+    const columnNameResult = field.dbFieldName().andThen((name) => name.value());
+    if (columnNameResult.isErr()) {
+      return err(
+        `Missing db field name for field ${field.id().toString()}: ${columnNameResult.error}`
+      );
+    }
+    const columnName = columnNameResult.value;
     this.builderRef.builder = this.builderRef.builder.addColumn(
       columnName,
       dataType

packages/v2/adapter-postgres-state/src/naming.ts

@@ -28,12 +28,3 @@ export const convertNameToValidCharacter = (name: string, maxLength = 40): strin
 export const joinDbTableName = (schemaName: string, tableName: string): string => {
   return `${schemaName}.${tableName}`;
 };
-
-export const splitDbTableName = (dbTableName: string): { schema: string; table: string } => {
-  const dotIndex = dbTableName.indexOf('.');
-  if (dotIndex === -1) return { schema: 'public', table: dbTableName };
-  return {
-    schema: dbTableName.slice(0, dotIndex),
-    table: dbTableName.slice(dotIndex + 1),
-  };
-};

packages/v2/adapter-postgres-state/src/repositories/PostgresTableRepository.spec.ts

@@ -247,6 +247,7 @@ describe('PostgresTableRepository (pg)', () => {
       const insertResult = await repo.insert(context, table);
       expect(insertResult.isOk()).toBe(true);
       if (insertResult.isErr()) return;
+      const persistedTable = insertResult.value;
 
       const persistedFields = await db
         .selectFrom('field')
@@ -263,6 +264,11 @@ describe('PostgresTableRepository (pg)', () => {
         table.name().toString(),
         40
       )}`;
+      const dbTableNameResult = persistedTable.dbTableName().andThen((name) => name.value());
+      expect(dbTableNameResult.isOk()).toBe(true);
+      if (dbTableNameResult.isErr()) return;
+      expect(dbTableNameResult.value).toBe(expectedDbTableName);
+
       const tableMetaRow = await db
         .selectFrom('table_meta')
         .select(['db_table_name', 'base_id'])
@@ -274,6 +280,15 @@ describe('PostgresTableRepository (pg)', () => {
       const expectedDbFieldNames = table
         .fields()
         .map((field) => convertNameToValidCharacter(field.name().toString(), 40));
+      const dbFieldNameResults = persistedTable
+        .fields()
+        .map((field) => field.dbFieldName().andThen((name) => name.value()));
+      expect(dbFieldNameResults.every((result) => result.isOk())).toBe(true);
+      if (dbFieldNameResults.some((result) => result.isErr())) return;
+      expect(dbFieldNameResults.map((result) => result._unsafeUnwrap())).toEqual(
+        expectedDbFieldNames
+      );
+
       const dbFieldRows = await db
         .selectFrom('field')
         .select(['db_field_name'])
@@ -294,6 +309,10 @@ describe('PostgresTableRepository (pg)', () => {
       expect(loaded.id().toString()).toBe(table.id().toString());
       expect(loaded.name().toString()).toBe(table.name().toString());
       expect(loaded.primaryFieldId().equals(table.primaryFieldId())).toBe(true);
+      const loadedDbTableNameResult = loaded.dbTableName().andThen((name) => name.value());
+      expect(loadedDbTableNameResult.isOk()).toBe(true);
+      if (loadedDbTableNameResult.isErr()) return;
+      expect(loadedDbTableNameResult.value).toBe(expectedDbTableName);
       expect(
         loaded.views().map((v) => ({ name: v.name().toString(), type: v.type().toString() }))
       ).toEqual([