Skip to content

The open alternative to Salesforce, designed for AI.

Add the private record column to every object table (#29374)

Charles Bochetb5312353ae33
diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/2-55/2-55-upgrade-version-command.module.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/2-55/2-55-upgrade-version-command.module.ts
index b115ac0ae62..41f2fe53998 100644
--- a/packages/twenty-server/src/database/commands/upgrade-version-command/2-55/2-55-upgrade-version-command.module.ts
+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/2-55/2-55-upgrade-version-command.module.ts
@@ -5,6 +5,7 @@ import { BackfillWebhookAdminRoleCommand } from 'src/database/commands/upgrade-v
import { AddStandardRelatedRecordPathsCommand } from 'src/database/commands/upgrade-version-command/2-55/2-55-workspace-command-1793375369182-add-standard-related-record-paths.command';
import { SyncAccessGroupObjectCommand } from 'src/database/commands/upgrade-version-command/2-55/2-55-workspace-command-1793384492383-sync-access-group-object.command';
import { AddAccessGroupStorageColumnsCommand } from 'src/database/commands/upgrade-version-command/2-55/2-55-workspace-command-1793391296027-add-access-group-storage-columns.command';
+import { AddPrivateRecordColumnCommand } from 'src/database/commands/upgrade-version-command/2-55/2-55-workspace-command-1793436309311-add-private-record-column.command';
import { ApplicationModule } from 'src/engine/core-modules/application/application.module';
import { WorkspaceSchemaManagerModule } from 'src/engine/twenty-orm/workspace-schema-manager/workspace-schema-manager.module';
import { WorkspaceCacheModule } from 'src/engine/workspace-cache/workspace-cache.module';
@@ -23,6 +24,7 @@ import { WorkspaceMigrationModule } from 'src/engine/workspace-manager/workspace
AddStandardRelatedRecordPathsCommand,
SyncAccessGroupObjectCommand,
AddAccessGroupStorageColumnsCommand,
+ AddPrivateRecordColumnCommand,
],
})
export class V2_55_UpgradeVersionCommandModule {}
diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/2-55/2-55-workspace-command-1793391296027-add-access-group-storage-columns.command.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/2-55/2-55-workspace-command-1793391296027-add-access-group-storage-columns.command.ts
index bace69c42d0..17115267ee7 100644
--- a/packages/twenty-server/src/database/commands/upgrade-version-command/2-55/2-55-workspace-command-1793391296027-add-access-group-storage-columns.command.ts
+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/2-55/2-55-workspace-command-1793391296027-add-access-group-storage-columns.command.ts
@@ -83,23 +83,6 @@ export class AddAccessGroupStorageColumnsCommand extends ProvisionedWorkspaceCom
tableSchema: { columnDefinitions: [], indexDefinitions: [] },
}),
});
- const conflictingColumnNames = columnDefinitions
- .filter(
- (columnDefinition) =>
- existingColumnTypes.has(columnDefinition.name) &&
- existingColumnTypes.get(columnDefinition.name) !==
- (columnDefinition.isArray ? '_int4' : 'int4'),
- )
- .map((columnDefinition) => columnDefinition.name);
-
- if (conflictingColumnNames.length > 0) {
- this.logger.error(
- `Skipping ${tableName} in workspace ${workspaceId}: column(s) ${conflictingColumnNames.join(', ')} already exist with another type`,
- );
-
- continue;
- }
-
const missingColumnDefinitions = columnDefinitions.filter(
(columnDefinition) => !existingColumnTypes.has(columnDefinition.name),
);
diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/2-55/2-55-workspace-command-1793436309311-add-private-record-column.command.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/2-55/2-55-workspace-command-1793436309311-add-private-record-column.command.ts
new file mode 100644
index 00000000000..b1782528cf1
--- /dev/null
+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/2-55/2-55-workspace-command-1793436309311-add-private-record-column.command.ts
@@ -0,0 +1,218 @@
+import { Command } from 'nest-commander';
+import { isDefined } from 'twenty-shared/utils';
+import { type QueryRunner } from 'typeorm';
+
+import { ProvisionedWorkspaceCommandRunner } from 'src/database/commands/command-runners/provisioned-workspace.command-runner';
+import { WorkspaceIteratorService } from 'src/database/commands/command-runners/workspace-iterator.service';
+import { type RunOnWorkspaceArgs } from 'src/database/commands/command-runners/workspace.command-runner';
+import { RegisteredWorkspaceCommand } from 'src/engine/core-modules/upgrade/decorators/registered-workspace-command.decorator';
+import { IS_PRIVATE_COLUMN_NAME } from 'src/engine/permissions/private-record/constants/is-private-column-name.constant';
+import { enrichRecordTableSchemaWithIsPrivate } from 'src/engine/permissions/private-record/utils/enrich-record-table-schema-with-is-private.util';
+import { type WorkspaceSchemaColumnDefinition } from 'src/engine/twenty-orm/workspace-schema-manager/types/workspace-schema-column-definition.type';
+import { WorkspaceSchemaManagerService } from 'src/engine/twenty-orm/workspace-schema-manager/workspace-schema-manager.service';
+import { WorkspaceCacheService } from 'src/engine/workspace-cache/services/workspace-cache.service';
+import { getWorkspaceSchemaName } from 'src/engine/workspace-datasource/utils/get-workspace-schema-name.util';
+import { getWorkspaceSchemaContextForMigration } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-runner/utils/get-workspace-schema-context-for-migration.util';
+
+@RegisteredWorkspaceCommand('2.55.0', 1793436309311)
+@Command({
+ name: 'upgrade:2-55:add-private-record-column',
+ description:
+ 'Add the _isPrivate column and its partial index to every object table except recordShare and accessGroup. Indexes are created with CONCURRENTLY so writes are not blocked.',
+})
+export class AddPrivateRecordColumnCommand extends ProvisionedWorkspaceCommandRunner {
+ constructor(
+ protected readonly workspaceIteratorService: WorkspaceIteratorService,
+ private readonly workspaceCacheService: WorkspaceCacheService,
+ private readonly workspaceSchemaManagerService: WorkspaceSchemaManagerService,
+ ) {
+ super(workspaceIteratorService);
+ }
+
+ override async runOnWorkspace({
+ workspaceId,
+ dataSource,
+ options,
+ }: RunOnWorkspaceArgs): Promise<void> {
+ if (!isDefined(dataSource)) {
+ this.logger.log(`No data source for workspace ${workspaceId}, skipping`);
+
+ return;
+ }
+
+ const { flatObjectMetadataMaps } =
+ await this.workspaceCacheService.getOrRecompute(workspaceId, [
+ 'flatObjectMetadataMaps',
+ ]);
+
+ const schemaName = getWorkspaceSchemaName(workspaceId);
+ const queryRunner = dataSource.createQueryRunner('master');
+ let isQueryRunnerConnected = false;
+ let dryRunColumnCount = 0;
+
+ try {
+ await queryRunner.connect();
+ isQueryRunnerConnected = true;
+
+ const existingTableNames = await this.findTableNames({
+ queryRunner,
+ schemaName,
+ });
+ const tableNamesWithColumn = await this.findTableNamesWithColumn({
+ queryRunner,
+ schemaName,
+ });
+
+ for (const flatObjectMetadata of Object.values(
+ flatObjectMetadataMaps.byUniversalIdentifier,
+ ).filter(isDefined)) {
+ const { columnDefinitions, indexDefinitions } =
+ enrichRecordTableSchemaWithIsPrivate({
+ objectMetadata: flatObjectMetadata,
+ tableSchema: { columnDefinitions: [], indexDefinitions: [] },
+ });
+
+ if (columnDefinitions.length === 0) {
+ continue;
+ }
+
+ const { tableName } = getWorkspaceSchemaContextForMigration({
+ workspaceId,
+ objectMetadata: flatObjectMetadata,
+ });
+
+ if (!existingTableNames.has(tableName)) {
+ continue;
+ }
+
+ const hasColumn = tableNamesWithColumn.has(tableName);
+
+ if (options.dryRun) {
+ dryRunColumnCount += hasColumn ? 0 : 1;
+
+ continue;
+ }
+
+ if (!hasColumn) {
+ await this.addColumnWithLockTimeout({
+ queryRunner,
+ schemaName,
+ tableName,
+ columnDefinitions,
+ });
+ }
+
+ for (const indexDefinition of indexDefinitions) {
+ await this.dropInvalidIndex({
+ queryRunner,
+ schemaName,
+ indexName: indexDefinition.name,
+ });
+ await this.workspaceSchemaManagerService.indexManager.createIndex({
+ queryRunner,
+ schemaName,
+ tableName,
+ index: indexDefinition,
+ concurrently: true,
+ });
+ }
+ }
+ } finally {
+ if (isQueryRunnerConnected) {
+ await queryRunner.release();
+ }
+ }
+
+ if (options.dryRun) {
+ this.logger.log(
+ `[DRY RUN] Would add ${dryRunColumnCount} column(s) for workspace ${workspaceId}`,
+ );
+ }
+ }
+
+ private async findTableNames({
+ queryRunner,
+ schemaName,
+ }: {
+ queryRunner: QueryRunner;
+ schemaName: string;
+ }): Promise<Set<string>> {
+ const tables: { tableName: string }[] = await queryRunner.query(
+ `SELECT table_name AS "tableName" FROM information_schema.tables WHERE table_schema = $1`,
+ [schemaName],
+ );
+
+ return new Set(tables.map(({ tableName }) => tableName));
+ }
+
+ private async findTableNamesWithColumn({
+ queryRunner,
+ schemaName,
+ }: {
+ queryRunner: QueryRunner;
+ schemaName: string;
+ }): Promise<Set<string>> {
+ const columns: { tableName: string }[] = await queryRunner.query(
+ `SELECT table_name AS "tableName" FROM information_schema.columns
+ WHERE table_schema = $1 AND column_name = $2`,
+ [schemaName, IS_PRIVATE_COLUMN_NAME],
+ );
+
+ return new Set(columns.map(({ tableName }) => tableName));
+ }
+
+ // Metadata-only, but the exclusive lock must not queue every query on the table
+ private async addColumnWithLockTimeout({
+ queryRunner,
+ schemaName,
+ tableName,
+ columnDefinitions,
+ }: {
+ queryRunner: QueryRunner;
+ schemaName: string;
+ tableName: string;
+ columnDefinitions: WorkspaceSchemaColumnDefinition[];
+ }): Promise<void> {
+ await queryRunner.query(`SET lock_timeout = '8s'`);
+
+ try {
+ await this.workspaceSchemaManagerService.columnManager.addColumns({
+ queryRunner,
+ schemaName,
+ tableName,
+ columnDefinitions,
+ });
+ } finally {
+ await queryRunner.query('RESET lock_timeout');
+ }
+ }
+
+ // An interrupted CREATE INDEX CONCURRENTLY leaves an invalid index that IF NOT EXISTS would keep
+ private async dropInvalidIndex({
+ queryRunner,
+ schemaName,
+ indexName,
+ }: {
+ queryRunner: QueryRunner;
+ schemaName: string;
+ indexName: string;
+ }): Promise<void> {
+ const invalidIndexes: { name: string }[] = await queryRunner.query(
+ `SELECT c.relname AS name
+ FROM pg_index i
+ JOIN pg_class c ON c.oid = i.indexrelid
+ JOIN pg_namespace n ON n.oid = c.relnamespace
+ WHERE n.nspname = $1 AND c.relname = $2 AND NOT i.indisvalid`,
+ [schemaName, indexName],
+ );
+
+ for (const { name } of invalidIndexes) {
+ await this.workspaceSchemaManagerService.indexManager.dropIndex({
+ queryRunner,
+ schemaName,
+ indexName: name,
+ concurrently: true,
+ });
+ }
+ }
+}
diff --git a/packages/twenty-server/src/engine/metadata-modules/access-group/constants/access-group-column-names.constant.ts b/packages/twenty-server/src/engine/metadata-modules/access-group/constants/access-group-column-names.constant.ts
index 7989c8f1058..e3d5d8b486a 100644
--- a/packages/twenty-server/src/engine/metadata-modules/access-group/constants/access-group-column-names.constant.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/access-group/constants/access-group-column-names.constant.ts
@@ -1,3 +1,4 @@
-export const ACCESS_GROUP_IDS_COLUMN_NAME = 'accessGroupIds';
+// Field names cannot start with an underscore, so no custom field can ever take this column
+export const ACCESS_GROUP_IDS_COLUMN_NAME = '_accessGroupIds';
export const ACCESS_GROUP_COMPACT_ID_COLUMN_NAME = 'compactId';
diff --git a/packages/twenty-server/src/engine/metadata-modules/access-group/utils/enrich-record-table-schema-with-access-group-ids.util.ts b/packages/twenty-server/src/engine/metadata-modules/access-group/utils/enrich-record-table-schema-with-access-group-ids.util.ts
index 70faa7e2879..d87fcc40dec 100644
--- a/packages/twenty-server/src/engine/metadata-modules/access-group/utils/enrich-record-table-schema-with-access-group-ids.util.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/access-group/utils/enrich-record-table-schema-with-access-group-ids.util.ts
@@ -1,7 +1,7 @@
import { ACCESS_GROUP_IDS_COLUMN_DEFINITION } from 'src/engine/metadata-modules/access-group/constants/access-group-ids-column-definition.constant';
import { type WorkspaceTableSchemaDefinitions } from 'src/engine/metadata-modules/access-group/types/workspace-table-schema-definitions.type';
import { buildAccessGroupIdsIndexDefinition } from 'src/engine/metadata-modules/access-group/utils/build-access-group-ids-index-definition.util';
-import { hasAccessGroupIds } from 'src/engine/metadata-modules/access-group/utils/has-access-group-ids.util';
+import { isPermissionStorageObject } from 'src/engine/permissions/utils/is-permission-storage-object.util';
import { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';
export const enrichRecordTableSchemaWithAccessGroupIds = ({
@@ -11,7 +11,7 @@ export const enrichRecordTableSchemaWithAccessGroupIds = ({
objectMetadata: Pick<FlatObjectMetadata, 'id' | 'universalIdentifier'>;
tableSchema: WorkspaceTableSchemaDefinitions;
}): WorkspaceTableSchemaDefinitions => {
- if (!hasAccessGroupIds(objectMetadata)) {
+ if (isPermissionStorageObject(objectMetadata)) {
return tableSchema;
}
diff --git a/packages/twenty-server/src/engine/metadata-modules/access-group/utils/has-access-group-ids.util.ts b/packages/twenty-server/src/engine/metadata-modules/access-group/utils/has-access-group-ids.util.ts
deleted file mode 100644
index 5b1a7356d38..00000000000
--- a/packages/twenty-server/src/engine/metadata-modules/access-group/utils/has-access-group-ids.util.ts
+++ /dev/null
@@ -1,16 +0,0 @@
-import { STANDARD_OBJECTS } from 'twenty-shared/metadata';
-
-import { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';
-
-// These objects store the permissions themselves, so access groups never apply to their records
-const OBJECT_UNIVERSAL_IDENTIFIERS_WITHOUT_ACCESS_GROUP_IDS: string[] = [
- STANDARD_OBJECTS.accessGroup.universalIdentifier,
- STANDARD_OBJECTS.recordShare.universalIdentifier,
-];
-
-export const hasAccessGroupIds = (
- objectMetadata: Pick<FlatObjectMetadata, 'universalIdentifier'>,
-): boolean =>
- !OBJECT_UNIVERSAL_IDENTIFIERS_WITHOUT_ACCESS_GROUP_IDS.includes(
- objectMetadata.universalIdentifier,
- );
diff --git a/packages/twenty-server/src/engine/metadata-modules/flat-field-metadata/validators/utils/validate-flat-field-metadata-name-availability.util.ts b/packages/twenty-server/src/engine/metadata-modules/flat-field-metadata/validators/utils/validate-flat-field-metadata-name-availability.util.ts
index c0519809297..164762e2fd6 100644
--- a/packages/twenty-server/src/engine/metadata-modules/flat-field-metadata/validators/utils/validate-flat-field-metadata-name-availability.util.ts
+++ b/packages/twenty-server/src/engine/metadata-modules/flat-field-metadata/validators/utils/validate-flat-field-metadata-name-availability.util.ts
@@ -2,7 +2,6 @@ import { msg } from '@lingui/core/macro';
import { compositeTypeDefinitions } from 'twenty-shared/types';
import { isDefined } from 'twenty-shared/utils';
-import { ACCESS_GROUP_IDS_COLUMN_NAME } from 'src/engine/metadata-modules/access-group/constants/access-group-column-names.constant';
import { FieldMetadataExceptionCode } from 'src/engine/metadata-modules/field-metadata/field-metadata.exception';
import { computeCompositeColumnName } from 'src/engine/metadata-modules/field-metadata/utils/compute-column-name.util';
import { isCompositeFieldMetadataType } from 'src/engine/metadata-modules/field-metadata/utils/is-composite-field-metadata-type.util';
@@ -74,15 +73,6 @@ export const validateFlatFieldMetadataNameAvailability = ({
});
}
- if (name === ACCESS_GROUP_IDS_COLUMN_NAME) {
- errors.push({
- code: FieldMetadataExceptionCode.RESERVED_KEYWORD,
- message: `Name "${name}" is reserved for access group storage`,
- value: name,
- userFriendlyMessage: msg`Name "${name}" is not available`,
- });
- }
-
const { objectFieldNamesAndJoinColumnNames } =
getObjectFieldNamesAndJoinColumnNames({
universalFlatFieldMetadataMaps,
diff --git a/packages/twenty-server/src/engine/permissions/constants/permission-storage-object-universal-identifiers.constant.ts b/packages/twenty-server/src/engine/permissions/constants/permission-storage-object-universal-identifiers.constant.ts
new file mode 100644
index 00000000000..418d5f27d2f
--- /dev/null
+++ b/packages/twenty-server/src/engine/permissions/constants/permission-storage-object-universal-identifiers.constant.ts
@@ -0,0 +1,7 @@
+import { STANDARD_OBJECTS } from 'twenty-shared/metadata';
+
+// These objects store the permissions themselves, so record permissions never apply to their records
+export const PERMISSION_STORAGE_OBJECT_UNIVERSAL_IDENTIFIERS: string[] = [
+ STANDARD_OBJECTS.accessGroup.universalIdentifier,
+ STANDARD_OBJECTS.recordShare.universalIdentifier,
+];
diff --git a/packages/twenty-server/src/engine/permissions/private-record/constants/is-private-column-definition.constant.ts b/packages/twenty-server/src/engine/permissions/private-record/constants/is-private-column-definition.constant.ts
new file mode 100644
index 00000000000..06cc3d639f4
--- /dev/null
+++ b/packages/twenty-server/src/engine/permissions/private-record/constants/is-private-column-definition.constant.ts
@@ -0,0 +1,12 @@
+/* @license Enterprise */
+
+import { IS_PRIVATE_COLUMN_NAME } from 'src/engine/permissions/private-record/constants/is-private-column-name.constant';
+import { type WorkspaceSchemaColumnDefinition } from 'src/engine/twenty-orm/workspace-schema-manager/types/workspace-schema-column-definition.type';
+
+// Outside field metadata so no API, view or manifest can read or set it without the sharing rules
+export const IS_PRIVATE_COLUMN_DEFINITION: WorkspaceSchemaColumnDefinition = {
+ name: IS_PRIVATE_COLUMN_NAME,
+ type: 'boolean',
+ isNullable: false,
+ default: false,
+};
diff --git a/packages/twenty-server/src/engine/permissions/private-record/constants/is-private-column-name.constant.ts b/packages/twenty-server/src/engine/permissions/private-record/constants/is-private-column-name.constant.ts
new file mode 100644
index 00000000000..76c8397b4d4
--- /dev/null
+++ b/packages/twenty-server/src/engine/permissions/private-record/constants/is-private-column-name.constant.ts
@@ -0,0 +1,4 @@
+/* @license Enterprise */
+
+// Field names cannot start with an underscore, so no custom field can ever take this column
+export const IS_PRIVATE_COLUMN_NAME = '_isPrivate';
diff --git a/packages/twenty-server/src/engine/permissions/private-record/utils/build-private-record-index-definition.util.ts b/packages/twenty-server/src/engine/permissions/private-record/utils/build-private-record-index-definition.util.ts
new file mode 100644
index 00000000000..57c19fbfcf7
--- /dev/null
+++ b/packages/twenty-server/src/engine/permissions/private-record/utils/build-private-record-index-definition.util.ts
@@ -0,0 +1,15 @@
+/* @license Enterprise */
+
+import { IS_PRIVATE_COLUMN_NAME } from 'src/engine/permissions/private-record/constants/is-private-column-name.constant';
+import { type WorkspaceSchemaIndexDefinition } from 'src/engine/twenty-orm/workspace-schema-manager/types/workspace-schema-index-definition.type';
+
+// Partial, so it only holds the few private records a creator or custodian lookup reads
+export const buildPrivateRecordIndexDefinition = ({
+ objectMetadataId,
+}: {
+ objectMetadataId: string;
+}): WorkspaceSchemaIndexDefinition => ({
+ name: `IDX_PRIVATE_RECORD_${objectMetadataId.replace(/-/g, '')}`,
+ columns: ['id'],
+ where: `"${IS_PRIVATE_COLUMN_NAME}"`,
+});
diff --git a/packages/twenty-server/src/engine/permissions/private-record/utils/enrich-record-table-schema-with-is-private.util.ts b/packages/twenty-server/src/engine/permissions/private-record/utils/enrich-record-table-schema-with-is-private.util.ts
new file mode 100644
index 00000000000..fdd7bf73e96
--- /dev/null
+++ b/packages/twenty-server/src/engine/permissions/private-record/utils/enrich-record-table-schema-with-is-private.util.ts
@@ -0,0 +1,33 @@
+/* @license Enterprise */
+
+import { IS_PRIVATE_COLUMN_DEFINITION } from 'src/engine/permissions/private-record/constants/is-private-column-definition.constant';
+import { buildPrivateRecordIndexDefinition } from 'src/engine/permissions/private-record/utils/build-private-record-index-definition.util';
+import { isPermissionStorageObject } from 'src/engine/permissions/utils/is-permission-storage-object.util';
+import { type WorkspaceTableSchemaDefinitions } from 'src/engine/metadata-modules/access-group/types/workspace-table-schema-definitions.type';
+import { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';
+
+export const enrichRecordTableSchemaWithIsPrivate = ({
+ objectMetadata,
+ tableSchema,
+}: {
+ objectMetadata: Pick<FlatObjectMetadata, 'id' | 'universalIdentifier'>;
+ tableSchema: WorkspaceTableSchemaDefinitions;
+}): WorkspaceTableSchemaDefinitions => {
+ if (isPermissionStorageObject(objectMetadata)) {
+ return tableSchema;
+ }
+
+ return {
+ ...tableSchema,
+ columnDefinitions: [
+ ...tableSchema.columnDefinitions,
+ IS_PRIVATE_COLUMN_DEFINITION,
+ ],
+ indexDefinitions: [
+ ...tableSchema.indexDefinitions,
+ buildPrivateRecordIndexDefinition({
+ objectMetadataId: objectMetadata.id,
+ }),
+ ],
+ };
+};
diff --git a/packages/twenty-server/src/engine/permissions/utils/is-permission-storage-object.util.ts b/packages/twenty-server/src/engine/permissions/utils/is-permission-storage-object.util.ts
new file mode 100644
index 00000000000..3bcaecef214
--- /dev/null
+++ b/packages/twenty-server/src/engine/permissions/utils/is-permission-storage-object.util.ts
@@ -0,0 +1,9 @@
+import { PERMISSION_STORAGE_OBJECT_UNIVERSAL_IDENTIFIERS } from 'src/engine/permissions/constants/permission-storage-object-universal-identifiers.constant';
+import { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';
+
+export const isPermissionStorageObject = (
+ objectMetadata: Pick<FlatObjectMetadata, 'universalIdentifier'>,
+): boolean =>
+ PERMISSION_STORAGE_OBJECT_UNIVERSAL_IDENTIFIERS.includes(
+ objectMetadata.universalIdentifier,
+ );
diff --git a/packages/twenty-server/src/engine/workspace-manager/workspace-migration/utils/validate-index-where-clause.util.ts b/packages/twenty-server/src/engine/workspace-manager/workspace-migration/utils/validate-index-where-clause.util.ts
index 2329d43bbf5..2e35c114355 100644
--- a/packages/twenty-server/src/engine/workspace-manager/workspace-migration/utils/validate-index-where-clause.util.ts
+++ b/packages/twenty-server/src/engine/workspace-manager/workspace-migration/utils/validate-index-where-clause.util.ts
@@ -1,5 +1,8 @@
// Any new pattern must be reviewed for SQL injection before being allowlisted
-const ALLOWED_INDEX_WHERE_CLAUSES = new Set(['"deletedAt" IS NULL']);
+const ALLOWED_INDEX_WHERE_CLAUSES = new Set([
+ '"deletedAt" IS NULL',
+ '"_isPrivate"',
+]);
export const validateAndReturnIndexWhereClause = (
clause: string | null | undefined,
diff --git a/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-runner/action-handlers/object/services/create-object-action-handler.service.ts b/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-runner/action-handlers/object/services/create-object-action-handler.service.ts
index 70d71771b5d..48ec8fc8cea 100644
--- a/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-runner/action-handlers/object/services/create-object-action-handler.service.ts
+++ b/packages/twenty-server/src/engine/workspace-manager/workspace-migration/workspace-migration-runner/action-handlers/object/services/create-object-action-handler.service.ts
@@ -5,6 +5,7 @@ import { v4 } from 'uuid';
import { WorkspaceMigrationRunnerActionHandler } from 'src/engine/workspace-manager/workspace-migration/workspace-migration-runner/interfaces/workspace-migration-runner-action-handler-service.interface';
+import { enrichRecordTableSchemaWithIsPrivate } from 'src/engine/permissions/private-record/utils/enrich-record-table-schema-with-is-private.util';
import { enrichAccessGroupTableSchema } from 'src/engine/metadata-modules/access-group/utils/enrich-access-group-table-schema.util';
import { enrichRecordTableSchemaWithAccessGroupIds } from 'src/engine/metadata-modules/access-group/utils/enrich-record-table-schema-with-access-group-ids.util';
import { ALL_METADATA_ENTITY_BY_METADATA_NAME } from 'src/engine/metadata-modules/flat-entity/constant/all-metadata-entity-by-metadata-name.constant';
@@ -175,11 +176,14 @@ export class CreateObjectActionHandlerService extends WorkspaceMigrationRunnerAc
workspaceSchemaManagerService: this.workspaceSchemaManagerService,
});
- const tableSchema = enrichRecordTableSchemaWithAccessGroupIds({
+ const tableSchema = enrichRecordTableSchemaWithIsPrivate({
objectMetadata: flatObjectMetadata,
- tableSchema: enrichAccessGroupTableSchema({
+ tableSchema: enrichRecordTableSchemaWithAccessGroupIds({
objectMetadata: flatObjectMetadata,
- tableSchema: { columnDefinitions, indexDefinitions: [] },
+ tableSchema: enrichAccessGroupTableSchema({
+ objectMetadata: flatObjectMetadata,
+ tableSchema: { columnDefinitions, indexDefinitions: [] },
+ }),
}),
});
diff --git a/packages/twenty-server/test/integration/metadata/suites/field-metadata/failing-create-one-field-metadata.integration-spec.ts b/packages/twenty-server/test/integration/metadata/suites/field-metadata/failing-create-one-field-metadata.integration-spec.ts
index a66974ea10d..a5b9ee1157b 100644
--- a/packages/twenty-server/test/integration/metadata/suites/field-metadata/failing-create-one-field-metadata.integration-spec.ts
+++ b/packages/twenty-server/test/integration/metadata/suites/field-metadata/failing-create-one-field-metadata.integration-spec.ts
@@ -86,25 +86,4 @@ describe('Failing create field metadata tests suite', () => {
expect(errorDetails).toContain(expectedMessage);
},
);
-
- it('should fail to create a field named accessGroupIds', async () => {
- const name = 'accessGroupIds';
-
- const { data, errors } = await createOneFieldMetadata({
- expectToFail: true,
- input: {
- objectMetadataId: createdObjectMetadataId,
- type: FieldMetadataType.TEXT,
- name,
- label: name,
- isLabelSyncedWithName: false,
- },
- gqlFields: 'id',
- });
-
- expect(data).toBeNull();
- expect(JSON.stringify(errors[0].extensions.errors)).toContain(
- 'reserved for access group storage',
- );
- });
});
diff --git a/packages/twenty-server/test/integration/upgrade/suites/2-42-workspace-command-1789914239896-migrate-agent-history-to-workspace.integration-spec.ts b/packages/twenty-server/test/integration/upgrade/suites/2-42-workspace-command-1789914239896-migrate-agent-history-to-workspace.integration-spec.ts
index ef9c016953f..dcc6d356b7d 100644
--- a/packages/twenty-server/test/integration/upgrade/suites/2-42-workspace-command-1789914239896-migrate-agent-history-to-workspace.integration-spec.ts
+++ b/packages/twenty-server/test/integration/upgrade/suites/2-42-workspace-command-1789914239896-migrate-agent-history-to-workspace.integration-spec.ts
@@ -57,7 +57,7 @@ const describeAgentMessageSenders = (dataSource: DataSource) =>
WHERE "senderWorkspaceMemberId" IS NOT NULL ORDER BY id`,
);
-// accessGroupIds comes from a later upgrade, so the 2.42 tables never have it
+// _accessGroupIds comes from a later upgrade, so the 2.42 tables never have it
const describeAgentHistoryColumns = ({
dataSource,
objectNames,
@@ -69,7 +69,7 @@ const describeAgentHistoryColumns = ({
`SELECT table_name AS "objectName", column_name AS "columnName"
FROM information_schema.columns
WHERE table_schema = $1 AND table_name = ANY($2)
- AND column_name <> 'accessGroupIds'
+ AND column_name <> '_accessGroupIds'
ORDER BY 1, 2`,
[SCHEMA, objectNames],
);
diff --git a/packages/twenty-server/test/integration/upgrade/suites/2-55-workspace-command-1793391296027-add-access-group-storage-columns.integration-spec.ts b/packages/twenty-server/test/integration/upgrade/suites/2-55-workspace-command-1793391296027-add-access-group-storage-columns.integration-spec.ts
index 764b454b3c9..aa986e00ad6 100644
--- a/packages/twenty-server/test/integration/upgrade/suites/2-55-workspace-command-1793391296027-add-access-group-storage-columns.integration-spec.ts
+++ b/packages/twenty-server/test/integration/upgrade/suites/2-55-workspace-command-1793391296027-add-access-group-storage-columns.integration-spec.ts
@@ -8,7 +8,7 @@ import { SEED_APPLE_WORKSPACE_ID } from 'src/engine/workspace-manager/dev-seeder
const SCHEMA = getWorkspaceSchemaName(SEED_APPLE_WORKSPACE_ID);
const RECORD_TABLE_NAMES = ['person', '_pet'];
-const ACCESS_GROUP_IDS = 'accessGroupIds';
+const ACCESS_GROUP_IDS = '_accessGroupIds';
type ColumnRow = {
tableName: string;
@@ -203,26 +203,4 @@ describe('2-55 workspace command - add access group storage columns (integration
);
}
});
-
- it('skips a table whose column of the same name has another type', async () => {
- await dropRecordColumn('_rocket');
- await global.testDataSource.query(
- `ALTER TABLE "${SCHEMA}"."_rocket" ADD COLUMN "${ACCESS_GROUP_IDS}" text`,
- );
-
- try {
- await runOnWorkspace();
-
- expect(
- (await findColumns())
- .filter((column) => column.tableName === '_rocket')
- .map((column) => [column.columnName, column.dataType]),
- ).toEqual([[ACCESS_GROUP_IDS, 'text']]);
- } finally {
- await global.testDataSource.query(
- `ALTER TABLE "${SCHEMA}"."_rocket" DROP COLUMN "${ACCESS_GROUP_IDS}"`,
- );
- await runOnWorkspace();
- }
- });
});
diff --git a/packages/twenty-server/test/integration/upgrade/suites/2-55-workspace-command-1793436309311-add-private-record-column.integration-spec.ts b/packages/twenty-server/test/integration/upgrade/suites/2-55-workspace-command-1793436309311-add-private-record-column.integration-spec.ts
new file mode 100644
index 00000000000..b4b7b637e40
--- /dev/null
+++ b/packages/twenty-server/test/integration/upgrade/suites/2-55-workspace-command-1793436309311-add-private-record-column.integration-spec.ts
@@ -0,0 +1,115 @@
+import { getAppProviderByClassName } from 'test/integration/utils/get-app-provider-by-class-name.util';
+
+import { type AddPrivateRecordColumnCommand } from 'src/database/commands/upgrade-version-command/2-55/2-55-workspace-command-1793436309311-add-private-record-column.command';
+import { getWorkspaceSchemaName } from 'src/engine/workspace-datasource/utils/get-workspace-schema-name.util';
+import { SEED_APPLE_WORKSPACE_ID } from 'src/engine/workspace-manager/dev-seeder/core/constants/seeder-workspaces.constant';
+
+const SCHEMA = getWorkspaceSchemaName(SEED_APPLE_WORKSPACE_ID);
+
+type ColumnRow = {
+ tableName: string;
+ dataType: string;
+ isNullable: string;
+ columnDefault: string | null;
+};
+
+describe('2-55 workspace command - add private record column (integration)', () => {
+ let command: AddPrivateRecordColumnCommand;
+ let personObjectMetadataId: string;
+ let petObjectMetadataId: string;
+
+ const runOnWorkspace = (options: { dryRun?: boolean } = {}) =>
+ command.runOnWorkspace({
+ workspaceId: SEED_APPLE_WORKSPACE_ID,
+ options,
+ index: 0,
+ total: 1,
+ dataSource: global.testDataSource,
+ });
+
+ const findColumns = (): Promise<ColumnRow[]> =>
+ global.testDataSource.query(
+ `SELECT table_name AS "tableName", udt_name AS "dataType",
+ is_nullable AS "isNullable", column_default AS "columnDefault"
+ FROM information_schema.columns
+ WHERE table_schema = $1 AND column_name = '_isPrivate'
+ ORDER BY table_name`,
+ [SCHEMA],
+ );
+
+ const findPrivateRecordIndex = async (
+ objectMetadataId: string,
+ ): Promise<{ definition: string; isValid: boolean } | undefined> => {
+ const [index] = await global.testDataSource.query(
+ `SELECT pg_get_indexdef(i.indexrelid) AS definition, i.indisvalid AS "isValid"
+ FROM pg_index i
+ JOIN pg_class c ON c.oid = i.indexrelid
+ JOIN pg_namespace n ON n.oid = c.relnamespace
+ WHERE n.nspname = $1 AND c.relname = $2`,
+ [SCHEMA, `IDX_PRIVATE_RECORD_${objectMetadataId.replace(/-/g, '')}`],
+ );
+
+ return index;
+ };
+
+ beforeAll(async () => {
+ command = getAppProviderByClassName<AddPrivateRecordColumnCommand>(
+ 'AddPrivateRecordColumnCommand',
+ );
+
+ [{ id: personObjectMetadataId }] = await global.testDataSource.query(
+ `SELECT id FROM core."objectMetadata" WHERE "workspaceId" = $1 AND "nameSingular" = 'person'`,
+ [SEED_APPLE_WORKSPACE_ID],
+ );
+ [{ id: petObjectMetadataId }] = await global.testDataSource.query(
+ `SELECT id FROM core."objectMetadata" WHERE "workspaceId" = $1 AND "nameSingular" = 'pet'`,
+ [SEED_APPLE_WORKSPACE_ID],
+ );
+ });
+
+ it('creates the column on standard and custom objects, not on permission storage', async () => {
+ const columns = await findColumns();
+
+ for (const tableName of ['person', '_pet']) {
+ expect(columns).toContainEqual({
+ tableName,
+ dataType: 'bool',
+ isNullable: 'NO',
+ columnDefault: 'false',
+ });
+ }
+ expect(
+ columns.filter(({ tableName }) =>
+ ['recordShare', 'accessGroup'].includes(tableName),
+ ),
+ ).toEqual([]);
+
+ expect(
+ (await findPrivateRecordIndex(personObjectMetadataId))?.definition,
+ ).toContain('WHERE "_isPrivate"');
+ });
+
+ it('adds a missing column back, but not on a dry run', async () => {
+ await global.testDataSource.query(
+ `ALTER TABLE "${SCHEMA}"."_pet" DROP COLUMN "_isPrivate"`,
+ );
+
+ await runOnWorkspace({ dryRun: true });
+ expect(
+ (await findColumns()).some(({ tableName }) => tableName === '_pet'),
+ ).toBe(false);
+
+ expect(await findPrivateRecordIndex(petObjectMetadataId)).toBeUndefined();
+
+ await runOnWorkspace();
+ await runOnWorkspace();
+ expect(
+ (await findColumns()).filter(({ tableName }) => tableName === '_pet'),
+ ).toHaveLength(1);
+
+ const petIndex = await findPrivateRecordIndex(petObjectMetadataId);
+
+ expect(petIndex?.isValid).toBe(true);
+ expect(petIndex?.definition).toContain('WHERE "_isPrivate"');
+ });
+});