The open alternative to Salesforce, designed for AI.
TypeScript crmcrm-systemcustomergood-first-issuegraphqlhacktoberfestjavascriptmarketingmonoreponestjsopen-sourcepostgresqlreactreactjssalestypescriptweb
Record sharing: inherited records follow the records their child rows point at (#25914)
martmull19288715df3e
diff --git a/packages/twenty-docs/developers/extend/apps/data/objects.mdx b/packages/twenty-docs/developers/extend/apps/data/objects.mdxindex bc8083841ef..3d0623e0b79 100644--- a/packages/twenty-docs/developers/extend/apps/data/objects.mdx+++ b/packages/twenty-docs/developers/extend/apps/data/objects.mdx@@ -82,7 +82,7 @@ export default defineObject({- `openRecordIn` sets where records of this object open when clicked: `ObjectOpenRecordIn.USER_CHOICE` (the default, following each workspace member's own preference from Settings → Experience), `ObjectOpenRecordIn.SIDE_PANEL`, or `ObjectOpenRecordIn.RECORD_PAGE`. Pin it to `RECORD_PAGE` for records that need a full page to be usable, the way workflows and dashboards do, or to `SIDE_PANEL` for records that only make sense as a quick panel, the way calendar events do.- `writability` controls who may write records of the object at all, before role permissions apply: `MetadataWritability.OPEN` (the default — workspace roles decide), `MetadataWritability.APPLICATION` (only your app's own logic functions can create, update, or delete records; use this for configuration-like objects whose records grant behavior, so workspace members with broad record access cannot edit them through the API), or `MetadataWritability.SYSTEM` (reserved for platform-managed data). Reads are unaffected — this is enforced server-side, unlike `isUIEditable`, which only hides UI affordances. It also exists per field, where it can only be stricter than the object's level.- `readability` declares who may read records of the object: `MetadataReadability.OPEN` (the default — workspace roles decide), `MetadataReadability.PRIVATE` (only principals the record was shared with), `MetadataReadability.INHERITED` (whoever reads the parent record), `MetadataReadability.APPLICATION` (only your app's own logic functions) or `MetadataReadability.SYSTEM` (platform-managed data). `SYSTEM` is always enforced. `PRIVATE`, `INHERITED` and `APPLICATION` are enforced on workspaces where record sharing is enabled (`IS_RECORD_SHARING_ENABLED`); elsewhere they still behave like `OPEN`.-- `readabilityParentFieldUniversalIdentifiers` goes with `MetadataReadability.INHERITED`: the universal identifiers of the many-to-one relation fields that point to the parent record. A record is readable when the parent it points to is readable; declaring one field of a morph relation covers every target of that relation. On top of that, an `INHERITED` record is readable through the share rows on the record itself exactly as a `PRIVATE` one is: its creator gets one when the record is created while record sharing is enabled, so whoever created a record keeps seeing it, and a record whose parent fields are all empty is visible to those it was shared with directly. An `INHERITED` object that names no usable parent field behaves like a `PRIVATE` one.+- `readabilityParentFieldUniversalIdentifiers` goes with `MetadataReadability.INHERITED`: the universal identifiers of the relation fields that lead to the parent records. A many-to-one field names the record the row points to, and declaring one field of a morph relation covers every target of that relation. A one-to-many field names a child object whose rows point back at the record, the join rows of a many-to-many relation: the record is then readable when at least one of those rows leads to a readable record, the way a note follows the people, companies and opportunities its note targets attach it to. Several parents combine as a union: one readable parent is enough. On top of that, an `INHERITED` record is readable through the share rows on the record itself exactly as a `PRIVATE` one is: its creator gets one when the record is created while record sharing is enabled, so whoever created a record keeps seeing it, and a record whose parent fields are all empty is visible to those it was shared with directly. An `INHERITED` object that names no usable parent field behaves like a `PRIVATE` one.- `color` sets the accent color of the object in the UI. Omit it and Twenty picks one for the object.- `imageIdentifierFieldMetadataUniversalIdentifier` names the field whose value is shown as the record avatar. Omit it to let Twenty pick the default.- `isLabelSyncedWithName`, on an object or on a field, keeps the API name in sync with the label when the label is edited in Settings. It defaults to `false`, so a renamed label leaves the name untouched.diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/2-41/2-41-upgrade-version-command.module.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/2-41/2-41-upgrade-version-command.module.tsindex a9474d856c5..9c70a475e84 100644--- a/packages/twenty-server/src/database/commands/upgrade-version-command/2-41/2-41-upgrade-version-command.module.ts+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/2-41/2-41-upgrade-version-command.module.ts@@ -6,6 +6,7 @@ import { CorrectStandardFieldAcronymCasingCommand } from 'src/database/commands/import { BackfillWorkspaceWorkflowIdOnWorkflowsCommand } from 'src/database/commands/upgrade-version-command/2-41/2-41-workspace-command-1789350000002-backfill-workspace-workflow-id-on-workflows.command';import { BackfillCoreVersionPointersCommand } from 'src/database/commands/upgrade-version-command/2-41/2-41-workspace-command-1789370101009-backfill-core-version-pointers.command';import { MakeStandardChildObjectsInheritedCommand } from 'src/database/commands/upgrade-version-command/2-41/2-41-workspace-command-1789373200001-make-standard-child-objects-inherited.command';+import { MakeNotesAndTasksInheritTheirTargetsCommand } from 'src/database/commands/upgrade-version-command/2-41/2-41-workspace-command-1789373200002-make-notes-and-tasks-inherit-their-targets.command';import { ApplicationModule } from 'src/engine/core-modules/application/application.module';import { FieldMetadataEntity } from 'src/engine/metadata-modules/field-metadata/field-metadata.entity';import { WorkspaceCacheModule } from 'src/engine/workspace-cache/workspace-cache.module';@@ -26,6 +27,7 @@ import { WorkspaceMigrationModule } from 'src/engine/workspace-manager/workspaceBackfillWorkspaceWorkflowIdOnWorkflowsCommand,BackfillCoreVersionPointersCommand,MakeStandardChildObjectsInheritedCommand,+ MakeNotesAndTasksInheritTheirTargetsCommand,],})export class V2_41_UpgradeVersionCommandModule {}diff --git a/packages/twenty-server/src/database/commands/upgrade-version-command/2-41/2-41-workspace-command-1789373200002-make-notes-and-tasks-inherit-their-targets.command.ts b/packages/twenty-server/src/database/commands/upgrade-version-command/2-41/2-41-workspace-command-1789373200002-make-notes-and-tasks-inherit-their-targets.command.tsnew file mode 100644index 00000000000..fd0018aa7d1--- /dev/null+++ b/packages/twenty-server/src/database/commands/upgrade-version-command/2-41/2-41-workspace-command-1789373200002-make-notes-and-tasks-inherit-their-targets.command.ts@@ -0,0 +1,186 @@+import { Command } from 'nest-commander';+import { STANDARD_OBJECT_FIELDS, STANDARD_OBJECTS } from 'twenty-shared/metadata';+import { MetadataReadability } from 'twenty-shared/types';+import { isDefined } from 'twenty-shared/utils';++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 { ApplicationService } from 'src/engine/core-modules/application/application.service';+import { RegisteredWorkspaceCommand } from 'src/engine/core-modules/upgrade/decorators/registered-workspace-command.decorator';+import { findFlatEntityByUniversalIdentifier } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-universal-identifier.util';+import { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';+import { WorkspaceCacheService } from 'src/engine/workspace-cache/services/workspace-cache.service';+import { WorkspaceMigrationValidateBuildAndRunService } from 'src/engine/workspace-manager/workspace-migration/services/workspace-migration-validate-build-and-run-service';++export const STANDARD_OBJECTS_TO_INHERIT_THROUGH_TARGETS = [+ {+ nameSingular: 'note',+ universalIdentifier: STANDARD_OBJECTS.note.universalIdentifier,+ readabilityParentFieldUniversalIdentifiers: [+ STANDARD_OBJECT_FIELDS.note.noteTargets.universalIdentifier,+ ],+ },+ {+ nameSingular: 'noteTarget',+ universalIdentifier: STANDARD_OBJECTS.noteTarget.universalIdentifier,+ readabilityParentFieldUniversalIdentifiers: [+ STANDARD_OBJECT_FIELDS.noteTarget.targetPerson.universalIdentifier,+ ],+ },+ {+ nameSingular: 'task',+ universalIdentifier: STANDARD_OBJECTS.task.universalIdentifier,+ readabilityParentFieldUniversalIdentifiers: [+ STANDARD_OBJECT_FIELDS.task.taskTargets.universalIdentifier,+ ],+ },+ {+ nameSingular: 'taskTarget',+ universalIdentifier: STANDARD_OBJECTS.taskTarget.universalIdentifier,+ readabilityParentFieldUniversalIdentifiers: [+ STANDARD_OBJECT_FIELDS.taskTarget.targetPerson.universalIdentifier,+ ],+ },+] as const;++const hasSameParentFields = (+ flatObjectMetadata: FlatObjectMetadata,+ readabilityParentFieldUniversalIdentifiers: readonly string[],+): boolean => {+ const current = flatObjectMetadata.readabilityParentFieldUniversalIdentifiers;++ return (+ isDefined(current) &&+ current.length === readabilityParentFieldUniversalIdentifiers.length &&+ readabilityParentFieldUniversalIdentifiers.every((universalIdentifier) =>+ current.includes(universalIdentifier),+ )+ );+};++@RegisteredWorkspaceCommand('2.41.0', 1789373200002)+@Command({+ name: 'upgrade:2-41:make-notes-and-tasks-inherit-their-targets',+ description:+ 'Set the readability of the existing note and task standard objects to INHERITED through their note targets and task targets, and point the existing noteTarget and taskTarget objects at their targets instead of the note or task, as the standard application now declares them; workspaces created after the change already have it',+})+export class MakeNotesAndTasksInheritTheirTargetsCommand extends ProvisionedWorkspaceCommandRunner {+ constructor(+ protected readonly workspaceIteratorService: WorkspaceIteratorService,+ private readonly applicationService: ApplicationService,+ private readonly workspaceCacheService: WorkspaceCacheService,+ private readonly workspaceMigrationValidateBuildAndRunService: WorkspaceMigrationValidateBuildAndRunService,+ ) {+ super(workspaceIteratorService);+ }++ override async runOnWorkspace({+ workspaceId,+ options,+ }: RunOnWorkspaceArgs): Promise<void> {+ const isDryRun = options.dryRun ?? false;++ const { flatObjectMetadataMaps } =+ await this.workspaceCacheService.getOrRecompute(workspaceId, [+ 'flatObjectMetadataMaps',+ ]);++ const flatObjectMetadatasToUpdate: FlatObjectMetadata[] = [];++ for (const {+ nameSingular,+ universalIdentifier,+ readabilityParentFieldUniversalIdentifiers,+ } of STANDARD_OBJECTS_TO_INHERIT_THROUGH_TARGETS) {+ const flatObjectMetadata =+ findFlatEntityByUniversalIdentifier<FlatObjectMetadata>({+ flatEntityMaps: flatObjectMetadataMaps,+ universalIdentifier,+ });++ if (!isDefined(flatObjectMetadata)) {+ this.logger.warn(+ `${nameSingular} object not found for workspace ${workspaceId}, skipping it`,+ );++ continue;+ }++ if (+ flatObjectMetadata.readability === MetadataReadability.INHERITED &&+ hasSameParentFields(+ flatObjectMetadata,+ readabilityParentFieldUniversalIdentifiers,+ )+ ) {+ continue;+ }++ flatObjectMetadatasToUpdate.push({+ ...flatObjectMetadata,+ readability: MetadataReadability.INHERITED,+ readabilityParentFieldUniversalIdentifiers: [+ ...readabilityParentFieldUniversalIdentifiers,+ ],+ updatedAt: new Date().toISOString(),+ });+ }++ if (flatObjectMetadatasToUpdate.length === 0) {+ this.logger.log(+ `Notes and tasks already inherit through their targets for workspace ${workspaceId}, skipping`,+ );++ return;+ }++ const objectNames = flatObjectMetadatasToUpdate+ .map((flatObjectMetadata) => flatObjectMetadata.nameSingular)+ .join(', ');++ this.logger.log(+ `${isDryRun ? '[DRY RUN] ' : ''}Making ${objectNames} inherit through their targets for workspace ${workspaceId}`,+ );++ if (isDryRun) {+ return;+ }++ const { twentyStandardFlatApplication } =+ await this.applicationService.findWorkspaceTwentyStandardAndCustomApplicationOrThrow(+ { workspaceId },+ );++ const validateAndBuildResult =+ await this.workspaceMigrationValidateBuildAndRunService.validateBuildAndRunWorkspaceMigration(+ {+ isSystemBuild: true,+ applicationUniversalIdentifier:+ twentyStandardFlatApplication.universalIdentifier,+ workspaceId,+ allFlatEntityOperationByMetadataName: {+ objectMetadata: {+ flatEntityToCreate: [],+ flatEntityToDelete: [],+ flatEntityToUpdate: flatObjectMetadatasToUpdate,+ },+ },+ },+ );++ if (validateAndBuildResult.status === 'fail') {+ throw new Error(+ `Failed to make ${objectNames} inherit through their targets for workspace ${workspaceId}: ${JSON.stringify(+ validateAndBuildResult,+ null,+ 2,+ )}`,+ );+ }++ this.logger.log(+ `Made ${objectNames} inherit through their targets for workspace ${workspaceId}`,+ );+ }+}diff --git a/packages/twenty-server/src/engine/twenty-orm/repository/workspace-repository.ts b/packages/twenty-server/src/engine/twenty-orm/repository/workspace-repository.tsindex 6286759dae9..db6c618e183 100644--- a/packages/twenty-server/src/engine/twenty-orm/repository/workspace-repository.ts+++ b/packages/twenty-server/src/engine/twenty-orm/repository/workspace-repository.ts@@ -32,8 +32,13 @@ import {} from 'src/engine/twenty-orm/repository/permissions.utils';import { resolveRequiredRecordShareAccessLevels } from 'src/engine/twenty-orm/repository/resolve-required-record-share-access-levels.util';import { type WorkspaceInternalContext } from 'src/engine/twenty-orm/interfaces/workspace-internal-context.interface';+import { type InheritedReadabilityChildrenParent } from 'src/engine/twenty-orm/types/inherited-readability-children-parent.type';+import { type InheritedReadabilityParent } from 'src/engine/twenty-orm/types/inherited-readability-parent.type';+import { type InheritedReadabilityParentLink } from 'src/engine/twenty-orm/types/inherited-readability-parent-link.type';import {buildInheritedReadabilityCondition,+ type InheritedReadabilityChildGate,+ type InheritedReadabilityParentCondition,type InheritedReadabilityParentGate,} from 'src/engine/twenty-orm/utils/build-inherited-readability-condition.util';import { buildRecordShareCondition } from 'src/engine/twenty-orm/utils/build-record-share-condition.util';@@ -47,10 +52,8 @@ import {import { isOwningApplicationAuthContext } from 'src/engine/twenty-orm/utils/is-owning-application-auth-context.util';import { renderRowLevelPermissionFilterToSql } from 'src/engine/twenty-orm/utils/render-row-level-permission-filter-to-sql.util';import { resolvePrincipalIdsFromAuthContext } from 'src/engine/twenty-orm/utils/resolve-principal-ids-from-auth-context.util';-import {- type InheritedReadabilityParent,- resolveInheritedReadabilityParents,-} from 'src/engine/twenty-orm/utils/resolve-inherited-readability-parents.util';+import { resolveInheritedReadabilityChildLinks } from 'src/engine/twenty-orm/utils/resolve-inherited-readability-child-links.util';+import { resolveInheritedReadabilityParents } from 'src/engine/twenty-orm/utils/resolve-inherited-readability-parents.util';import { resolveRowLevelPermissionRecordFilter } from 'src/engine/twenty-orm/utils/resolve-row-level-permission-record-filter.util';import { validateRLSPredicatesForRecords } from 'src/engine/twenty-orm/utils/validate-rls-predicates-for-records.util';import {@@ -963,7 +966,10 @@ export class WorkspaceRepository<TEntity extends ObjectLiteral = ObjectRecord> {this.formatResult<ObjectRecord[]>(formattedRecords),);- await this.validateInheritedParentsAreWritableOrThrow(formattedRecords);+ await this.validateInheritedParentsAreWritableOrThrow({+ writtenRecords: formattedRecords,+ affectedRecords: formattedRecords,+ });const sql = buildInsertStatement({tableShape: this.options.tableShape,@@ -1063,10 +1069,20 @@ export class WorkspaceRepository<TEntity extends ObjectLiteral = ObjectRecord> {dataByInputIndex = enriched.entities as Partial<ObjectRecord>[];}- await this.validateInheritedParentsAreWritableOrThrow(- dataByInputIndex.map((data) => this.formatWriteData(data)),+ const writtenRecords = dataByInputIndex.map((data) =>+ this.formatWriteData(data),);+ await this.validateInheritedParentsAreWritableOrThrow({+ writtenRecords,+ affectedRecords: writtenRecords.flatMap((writtenRecord, index) =>+ rawBeforeByInputIndex[index].flatMap((rawBefore) => [+ rawBefore,+ { ...rawBefore, ...writtenRecord },+ ]),+ ),+ });+for (const [index, input] of writableInputs.entries()) {const { id: _id, ...setColumns } = this.formatWriteData(dataByInputIndex[index],@@ -1257,60 +1273,125 @@ export class WorkspaceRepository<TEntity extends ObjectLiteral = ObjectRecord> {}// Re-parenting a child, or creating one under a parent, is a write on that- // parent: the destination must grant the caller at least READ_WRITE- private async validateInheritedParentsAreWritableOrThrow(- records: Record<string, unknown>[],- ): Promise<void> {- if (- this.options.shouldBypassPermissionChecks ||- !this.isRecordSharingEnabled() ||- this.options.flatObjectMetadata.readability !==- MetadataReadability.INHERITED ||- isOwningApplicationAuthContext({- authContext: this.options.authContext,- owningApplicationId: this.options.flatObjectMetadata.applicationId,- })- ) {+ // parent: the destination must grant the caller at least READ_WRITE. The+ // records inheriting through a row are checked on the row before and after+ // the write, whatever the write is, since creating, changing, deleting or+ // restoring the row changes what they expose+ private async validateInheritedParentsAreWritableOrThrow({+ writtenRecords,+ affectedRecords,+ }: {+ writtenRecords: Record<string, unknown>[];+ affectedRecords: Record<string, unknown>[];+ }): Promise<void> {+ if (!this.shouldValidateInheritedParents()) {return;}- for (const parent of this.resolveInheritedReadabilityParents(- this.options.flatObjectMetadata,- )) {- const parentIds = [- ...new Set(- records- .map((record) => record[parent.joinColumnName])- .filter(isNonEmptyString),- ),- ];+ for (const parent of this.resolveOwnParentLinks()) {+ await this.validateParentRecordsAreWritableOrThrow({+ parent,+ records: writtenRecords,+ });+ }- if (parentIds.length === 0) {- continue;- }+ for (const parent of this.resolveInheritingRecordLinks()) {+ await this.validateParentRecordsAreWritableOrThrow({+ parent,+ records: affectedRecords,+ });+ }+ }- const parentRepository = this.options.getRepositoryForObjectMetadataId(- parent.parentFlatObjectMetadata.id,- );- const queryBuilder = parentRepository- .createQueryBuilder()- .where({ id: In(parentIds) })- .withDeleted();+ private shouldValidateInheritedParents(): boolean {+ return (+ !this.options.shouldBypassPermissionChecks &&+ this.isRecordSharingEnabled()+ );+ }- parentRepository.applyWriteRowLevelPermissions(queryBuilder, 'update');- queryBuilder.select(['id']);+ private hasInheritingRecordLinks(): boolean {+ return (+ this.shouldValidateInheritedParents() &&+ this.resolveInheritingRecordLinks().length > 0+ );+ }- const writableParentRows = await queryBuilder.getMany<ObjectRecord>({- noFormatting: true,- });+ private async validateParentRecordsAreWritableOrThrow({+ parent,+ records,+ }: {+ parent: InheritedReadabilityParentLink;+ records: Record<string, unknown>[];+ }): Promise<void> {+ const parentIds = [+ ...new Set(+ records+ .map((record) => record[parent.joinColumnName])+ .filter(isNonEmptyString),+ ),+ ];- if (writableParentRows.length !== parentIds.length) {- throw new PermissionsException(- `${PermissionsExceptionMessage.PERMISSION_DENIED}: the "${parent.parentFlatObjectMetadata.nameSingular}" record a "${this.options.flatObjectMetadata.nameSingular}" is attached to is not writable`,- PermissionsExceptionCode.PERMISSION_DENIED,- );- }+ if (parentIds.length === 0) {+ return;+ }++ const parentRepository = this.options.getRepositoryForObjectMetadataId(+ parent.parentFlatObjectMetadata.id,+ );+ const queryBuilder = parentRepository+ .createQueryBuilder()+ .where({ id: In(parentIds) })+ .withDeleted();++ parentRepository.applyWriteRowLevelPermissions(queryBuilder, 'update');+ queryBuilder.select(['id']);++ const writableParentRows = await queryBuilder.getMany<ObjectRecord>({+ noFormatting: true,+ });++ if (writableParentRows.length !== parentIds.length) {+ throw new PermissionsException(+ `${PermissionsExceptionMessage.PERMISSION_DENIED}: the "${parent.parentFlatObjectMetadata.nameSingular}" record a "${this.options.flatObjectMetadata.nameSingular}" is attached to is not writable`,+ PermissionsExceptionCode.PERMISSION_DENIED,+ );+ }+ }++ private resolveOwnParentLinks(): InheritedReadabilityParentLink[] {+ const { flatObjectMetadata } = this.options;++ if (+ flatObjectMetadata.readability !== MetadataReadability.INHERITED ||+ isOwningApplicationAuthContext({+ authContext: this.options.authContext,+ owningApplicationId: flatObjectMetadata.applicationId,+ })+ ) {+ return [];}++ return this.resolveInheritedReadabilityParents(flatObjectMetadata).flatMap(+ (parent) =>+ parent.kind === 'column'+ ? [+ {+ joinColumnName: parent.joinColumnName,+ parentFlatObjectMetadata: parent.parentFlatObjectMetadata,+ },+ ]+ : [],+ );+ }++ private resolveInheritingRecordLinks(): InheritedReadabilityParentLink[] {+ return resolveInheritedReadabilityChildLinks({+ flatObjectMetadata: this.options.flatObjectMetadata,+ flatFieldMetadataMaps: this.options.internalContext.flatFieldMetadataMaps,+ flatObjectMetadataMaps:+ this.options.internalContext.flatObjectMetadataMaps,+ });}private isRecordSharingEnabled(): boolean {@@ -1431,10 +1512,27 @@ export class WorkspaceRepository<TEntity extends ObjectLiteral = ObjectRecord> {),'Updated record does not satisfy row-level security constraints of your current role',);-- await this.validateInheritedParentsAreWritableOrThrow([setColumns]);}+ // The delete snapshot keeps a single row for the event while every deleted+ // row may be one some record inherits through+ const recordsBeforeInheritanceCheck =+ kind === 'delete' && this.hasInheritingRecordLinks()+ ? await eventSelectQueryBuilder.getMany<ObjectRecord>({+ noFormatting: true,+ })+ : recordsBefore;++ await this.validateInheritedParentsAreWritableOrThrow({+ writtenRecords: isDefined(setColumns) ? [setColumns] : [],+ affectedRecords: isDefined(setColumns)+ ? recordsBeforeInheritanceCheck.flatMap((record) => [+ record,+ { ...record, ...setColumns },+ ])+ : recordsBeforeInheritanceCheck,+ });+const mutationResult = await this.morphAndExecute({selectQueryBuilder,kind,@@ -1874,8 +1972,9 @@ export class WorkspaceRepository<TEntity extends ObjectLiteral = ObjectRecord> {isDefined(joinParentRelationShape) &&parents.some((parent) =>+ parent.kind === 'column' &&parent.fieldMetadataId ===- joinParentRelationShape.targetFieldMetadataId,+ joinParentRelationShape.targetFieldMetadataId,)) {return;@@ -1941,18 +2040,141 @@ export class WorkspaceRepository<TEntity extends ObjectLiteral = ObjectRecord> {recordShareTableExpression: this.getRecordShareTableExpression(),principalIds,accessLevels,- parents: parents.map(({ joinColumnName, parentFlatObjectMetadata }) => ({- joinColumnName,- gate: this.resolveInheritedReadabilityParentGate({- tableAlias,- joinColumnName,- parentFlatObjectMetadata,+ parents: parents.map((parent) =>+ parent.kind === 'column'+ ? {+ kind: 'column',+ joinColumnName: parent.joinColumnName,+ gate: this.resolveInheritedReadabilityParentGate({+ tableAlias,+ joinColumnName: parent.joinColumnName,+ parentFlatObjectMetadata: parent.parentFlatObjectMetadata,+ principalIds,+ accessLevels,+ depth,+ }),+ }+ : this.buildInheritedReadabilityChildrenCondition({+ tableAlias,+ parent,+ principalIds,+ accessLevels,+ depth,+ }),+ ),+ });+ }++ private buildInheritedReadabilityChildrenCondition({+ tableAlias,+ parent,+ principalIds,+ accessLevels,+ depth,+ }: {+ tableAlias: string;+ parent: InheritedReadabilityChildrenParent;+ principalIds: string[];+ accessLevels: RecordShareAccessLevel[];+ depth: number;+ }): InheritedReadabilityParentCondition {+ const { childFlatObjectMetadata, childJoinColumnName } = parent;+ const childTableAlias = `${tableAlias}_${childFlatObjectMetadata.nameSingular}`;+ const childTableShape = this.options.tableShapeByObjectMetadataId(+ childFlatObjectMetadata.id,+ );++ return {+ kind: 'children',+ childTableAlias,+ childTableExpression: `${escapeIdentifier(+ childTableShape.schemaName,+ )}.${escapeIdentifier(childTableShape.tableName)}`,+ childJoinColumnName,+ gate: this.resolveInheritedReadabilityChildGate({+ childTableAlias,+ childFlatObjectMetadata,+ principalIds,+ accessLevels,+ depth,+ }),+ };+ }++ // A child row grants access when the child object's own gate lets the caller+ // read it: OPEN needs the row alone, PRIVATE a share row on it, INHERITED its+ // own parents evaluated one level deeper, or a share row on it when it has+ // no usable parent, as a root INHERITED record without one+ private resolveInheritedReadabilityChildGate({+ childTableAlias,+ childFlatObjectMetadata,+ principalIds,+ accessLevels,+ depth,+ }: {+ childTableAlias: string;+ childFlatObjectMetadata: FlatObjectMetadata;+ principalIds: string[];+ accessLevels: RecordShareAccessLevel[];+ depth: number;+ }): InheritedReadabilityChildGate {+ if (+ isOwningApplicationAuthContext({+ authContext: this.options.authContext,+ owningApplicationId: childFlatObjectMetadata.applicationId,+ })+ ) {+ return { kind: 'open' };+ }++ const ownRecordShareGate: InheritedReadabilityChildGate = {+ kind: 'gated',+ condition: buildRecordShareCondition({+ tableAlias: childTableAlias,+ recordShareTableExpression: this.getRecordShareTableExpression(),+ objectMetadataId: childFlatObjectMetadata.id,+ principalIds,+ accessLevels,+ }),+ };++ switch (childFlatObjectMetadata.readability) {+ case MetadataReadability.OPEN:+ return { kind: 'open' };+ case MetadataReadability.SYSTEM:+ case MetadataReadability.APPLICATION:+ return { kind: 'denied' };+ case MetadataReadability.PRIVATE:+ return ownRecordShareGate;+ case MetadataReadability.INHERITED: {+ if (depth >= MAX_INHERITED_READABILITY_DEPTH) {+ return { kind: 'denied' };+ }++ const childParents = this.resolveInheritedReadabilityParents(+ childFlatObjectMetadata,+ );++ if (childParents.length === 0) {+ return ownRecordShareGate;+ }++ const condition = this.buildInheritedReadabilityConditionForAlias({+ tableAlias: childTableAlias,+ objectMetadataId: childFlatObjectMetadata.id,+ parents: childParents,principalIds,accessLevels,- depth,- }),- })),- });+ depth: depth + 1,+ });++ return isDefined(condition)+ ? { kind: 'gated', condition }+ : { kind: 'open' };+ }+ default:+ assertUnreachable(childFlatObjectMetadata.readability);+ }}private resolveInheritedReadabilityParentGate({diff --git a/packages/twenty-server/src/engine/twenty-orm/types/inherited-readability-children-parent.type.ts b/packages/twenty-server/src/engine/twenty-orm/types/inherited-readability-children-parent.type.tsnew file mode 100644index 00000000000..9a306fb1cc9--- /dev/null+++ b/packages/twenty-server/src/engine/twenty-orm/types/inherited-readability-children-parent.type.ts@@ -0,0 +1,8 @@+import { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';++export type InheritedReadabilityChildrenParent = {+ kind: 'children';+ fieldMetadataId: string;+ childJoinColumnName: string;+ childFlatObjectMetadata: FlatObjectMetadata;+};diff --git a/packages/twenty-server/src/engine/twenty-orm/types/inherited-readability-column-parent.type.ts b/packages/twenty-server/src/engine/twenty-orm/types/inherited-readability-column-parent.type.tsnew file mode 100644index 00000000000..3418bc1b986--- /dev/null+++ b/packages/twenty-server/src/engine/twenty-orm/types/inherited-readability-column-parent.type.ts@@ -0,0 +1,8 @@+import { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';++export type InheritedReadabilityColumnParent = {+ kind: 'column';+ fieldMetadataId: string;+ joinColumnName: string;+ parentFlatObjectMetadata: FlatObjectMetadata;+};diff --git a/packages/twenty-server/src/engine/twenty-orm/types/inherited-readability-parent-link.type.ts b/packages/twenty-server/src/engine/twenty-orm/types/inherited-readability-parent-link.type.tsnew file mode 100644index 00000000000..d7a084615b9--- /dev/null+++ b/packages/twenty-server/src/engine/twenty-orm/types/inherited-readability-parent-link.type.ts@@ -0,0 +1,6 @@+import { type InheritedReadabilityColumnParent } from 'src/engine/twenty-orm/types/inherited-readability-column-parent.type';++export type InheritedReadabilityParentLink = Pick<+ InheritedReadabilityColumnParent,+ 'joinColumnName' | 'parentFlatObjectMetadata'+>;diff --git a/packages/twenty-server/src/engine/twenty-orm/types/inherited-readability-parent.type.ts b/packages/twenty-server/src/engine/twenty-orm/types/inherited-readability-parent.type.tsnew file mode 100644index 00000000000..5e13e7541fc--- /dev/null+++ b/packages/twenty-server/src/engine/twenty-orm/types/inherited-readability-parent.type.ts@@ -0,0 +1,6 @@+import { type InheritedReadabilityChildrenParent } from 'src/engine/twenty-orm/types/inherited-readability-children-parent.type';+import { type InheritedReadabilityColumnParent } from 'src/engine/twenty-orm/types/inherited-readability-column-parent.type';++export type InheritedReadabilityParent =+ | InheritedReadabilityColumnParent+ | InheritedReadabilityChildrenParent;diff --git a/packages/twenty-server/src/engine/twenty-orm/utils/__tests__/build-inherited-readability-condition.util.spec.ts b/packages/twenty-server/src/engine/twenty-orm/utils/__tests__/build-inherited-readability-condition.util.spec.tsindex 41b0cb7e1b1..0f48af3dc59 100644--- a/packages/twenty-server/src/engine/twenty-orm/utils/__tests__/build-inherited-readability-condition.util.spec.ts+++ b/packages/twenty-server/src/engine/twenty-orm/utils/__tests__/build-inherited-readability-condition.util.spec.ts@@ -38,8 +38,16 @@ const findParameterValues = (describe('buildInheritedReadabilityCondition', () => {it('should accept a share row on the record itself or an OPEN parent present', () => {const condition = build([- { joinColumnName: 'targetPersonId', gate: { kind: 'open' } },- { joinColumnName: 'targetCompanyId', gate: { kind: 'open' } },+ {+ kind: 'column',+ joinColumnName: 'targetPersonId',+ gate: { kind: 'open' },+ },+ {+ kind: 'column',+ joinColumnName: 'targetCompanyId',+ gate: { kind: 'open' },+ },]);expect(condition).toBeDefined();@@ -58,8 +66,13 @@ describe('buildInheritedReadabilityCondition', () => {it('should gate a PRIVATE parent on one record share EXISTS keyed by the parent column', () => {const condition = build([- { joinColumnName: 'targetPersonId', gate: { kind: 'open' } },{+ kind: 'column',+ joinColumnName: 'targetPersonId',+ gate: { kind: 'open' },+ },+ {+ kind: 'column',joinColumnName: 'targetNoteId',gate: { kind: 'private', objectMetadataId: NOTE_OBJECT_METADATA_ID },},@@ -81,7 +94,11 @@ describe('buildInheritedReadabilityCondition', () => {it('should only keep rows shared directly when every parent is denied', () => {const condition = build([- { joinColumnName: 'targetNoteId', gate: { kind: 'denied' } },+ {+ kind: 'column',+ joinColumnName: 'targetNoteId',+ gate: { kind: 'denied' },+ },]);expect(condition).toBeDefined();@@ -96,6 +113,7 @@ describe('buildInheritedReadabilityCondition', () => {it('should correlate an INHERITED parent through its own condition', () => {const condition = build([{+ kind: 'column',joinColumnName: 'targetNoteId',gate: {kind: 'inherited',@@ -118,4 +136,57 @@ describe('buildInheritedReadabilityCondition', () => {);expect(parameters.nested).toBe('value');});++ it('should accept any live child row of an OPEN child object', () => {+ const condition = build([+ {+ kind: 'children',+ childTableAlias: 'attachment_noteTarget',+ childTableExpression: '"workspace_abc"."noteTarget"',+ childJoinColumnName: 'noteId',+ gate: { kind: 'open' },+ },+ ]);++ expect(condition).toBeDefined();++ expect(condition!.sql).toContain(+ ' OR EXISTS (SELECT 1 FROM "workspace_abc"."noteTarget" AS "attachment_noteTarget" WHERE "attachment_noteTarget"."noteId" = "attachment"."id" AND "attachment_noteTarget"."deletedAt" IS NULL))',+ );+ });++ it('should require a readable child row of a gated child object and skip a denied one', () => {+ const condition = build([+ {+ kind: 'children',+ childTableAlias: 'attachment_noteTarget',+ childTableExpression: '"workspace_abc"."noteTarget"',+ childJoinColumnName: 'noteId',+ gate: {+ kind: 'gated',+ condition: {+ sql: '"attachment_noteTarget"."targetPersonId" IS NOT NULL',+ parameters: { nested: 'value' },+ },+ },+ },+ {+ kind: 'children',+ childTableAlias: 'attachment_secret',+ childTableExpression: '"workspace_abc"."secret"',+ childJoinColumnName: 'attachmentId',+ gate: { kind: 'denied' },+ },+ ]);++ expect(condition).toBeDefined();++ const { sql, parameters } = condition!;++ expect(sql).toContain(+ ' OR EXISTS (SELECT 1 FROM "workspace_abc"."noteTarget" AS "attachment_noteTarget" WHERE "attachment_noteTarget"."noteId" = "attachment"."id" AND "attachment_noteTarget"."deletedAt" IS NULL AND "attachment_noteTarget"."targetPersonId" IS NOT NULL))',+ );+ expect(sql).not.toContain('secret');+ expect(parameters.nested).toBe('value');+ });});diff --git a/packages/twenty-server/src/engine/twenty-orm/utils/__tests__/resolve-inherited-readability-child-links.util.spec.ts b/packages/twenty-server/src/engine/twenty-orm/utils/__tests__/resolve-inherited-readability-child-links.util.spec.tsnew file mode 100644index 00000000000..0e5a96047a4--- /dev/null+++ b/packages/twenty-server/src/engine/twenty-orm/utils/__tests__/resolve-inherited-readability-child-links.util.spec.ts@@ -0,0 +1,124 @@+import { FieldMetadataType, MetadataReadability } from 'twenty-shared/types';++import { RelationType } from 'src/engine/metadata-modules/field-metadata/interfaces/relation-type.interface';++import { type FlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/flat-entity-maps.type';+import { getFlatFieldMetadataMock } from 'src/engine/metadata-modules/flat-field-metadata/__mocks__/get-flat-field-metadata.mock';+import { type FlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/types/flat-field-metadata.type';+import { getFlatObjectMetadataMock } from 'src/engine/metadata-modules/flat-object-metadata/__mocks__/get-flat-object-metadata.mock';+import { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';+import { resolveInheritedReadabilityChildLinks } from 'src/engine/twenty-orm/utils/resolve-inherited-readability-child-links.util';++const ATTACHMENT_OBJECT_ID = 'attachment-object-id';+const NOTE_OBJECT_ID = 'note-object-id';+const NOTE_ATTACHMENTS_FIELD_ID = 'note-attachments-field-id';+const TARGET_NOTE_FIELD_ID = 'target-note-field-id';++const targetNoteField = getFlatFieldMetadataMock({+ id: TARGET_NOTE_FIELD_ID,+ name: 'targetNote',+ type: FieldMetadataType.MORPH_RELATION,+ universalIdentifier: `${TARGET_NOTE_FIELD_ID}-universal-identifier`,+ objectMetadataId: ATTACHMENT_OBJECT_ID,+ relationTargetObjectMetadataId: NOTE_OBJECT_ID,+ relationTargetFieldMetadataId: NOTE_ATTACHMENTS_FIELD_ID,+ morphId: 'target-morph-id',+ settings: {+ relationType: RelationType.MANY_TO_ONE,+ joinColumnName: 'targetNoteId',+ },+} as Parameters<typeof getFlatFieldMetadataMock>[0]);++const noteAttachmentsField = getFlatFieldMetadataMock({+ id: NOTE_ATTACHMENTS_FIELD_ID,+ name: 'attachments',+ type: FieldMetadataType.RELATION,+ universalIdentifier: `${NOTE_ATTACHMENTS_FIELD_ID}-universal-identifier`,+ objectMetadataId: NOTE_OBJECT_ID,+ relationTargetObjectMetadataId: ATTACHMENT_OBJECT_ID,+ relationTargetFieldMetadataId: TARGET_NOTE_FIELD_ID,+ settings: { relationType: RelationType.ONE_TO_MANY },+} as Parameters<typeof getFlatFieldMetadataMock>[0]);++const buildFlatEntityMaps = <T extends FlatFieldMetadata | FlatObjectMetadata>(+ flatEntities: T[],+): FlatEntityMaps<T> => ({+ byUniversalIdentifier: Object.fromEntries(+ flatEntities.map((flatEntity) => [+ flatEntity.universalIdentifier,+ flatEntity,+ ]),+ ),+ universalIdentifierById: Object.fromEntries(+ flatEntities.map((flatEntity) => [+ flatEntity.id,+ flatEntity.universalIdentifier,+ ]),+ ),+ universalIdentifiersByApplicationId: {},+});++const attachmentFlatObjectMetadata = getFlatObjectMetadataMock({+ id: ATTACHMENT_OBJECT_ID,+ universalIdentifier: 'attachment-object-universal-identifier',+ nameSingular: 'attachment',+ fieldIds: [targetNoteField.id],+});++const buildNoteObject = ({+ readability,+ readabilityParentFieldUniversalIdentifiers,+}: {+ readability: MetadataReadability;+ readabilityParentFieldUniversalIdentifiers: string[] | null;+}) =>+ getFlatObjectMetadataMock({+ id: NOTE_OBJECT_ID,+ universalIdentifier: 'note-object-universal-identifier',+ nameSingular: 'note',+ fieldIds: [noteAttachmentsField.id],+ readability,+ readabilityParentFieldUniversalIdentifiers,+ });++const resolveForAttachment = (noteFlatObjectMetadata: FlatObjectMetadata) =>+ resolveInheritedReadabilityChildLinks({+ flatObjectMetadata: attachmentFlatObjectMetadata,+ flatFieldMetadataMaps: buildFlatEntityMaps([+ targetNoteField,+ noteAttachmentsField,+ ]),+ flatObjectMetadataMaps: buildFlatEntityMaps([+ attachmentFlatObjectMetadata,+ noteFlatObjectMetadata,+ ]),+ }).map(({ joinColumnName, parentFlatObjectMetadata }) => ({+ joinColumnName,+ parentNameSingular: parentFlatObjectMetadata.nameSingular,+ }));++describe('resolveInheritedReadabilityChildLinks', () => {+ it('should link a row to the records that inherit through it', () => {+ expect(+ resolveForAttachment(+ buildNoteObject({+ readability: MetadataReadability.INHERITED,+ readabilityParentFieldUniversalIdentifiers: [+ noteAttachmentsField.universalIdentifier,+ ],+ }),+ ),+ ).toEqual([{ joinColumnName: 'targetNoteId', parentNameSingular: 'note' }]);+ });++ it('should link nothing when the pointed record does not inherit through the row', () => {+ expect(+ resolveForAttachment(+ buildNoteObject({+ readability: MetadataReadability.OPEN,+ readabilityParentFieldUniversalIdentifiers: null,+ }),+ ),+ ).toEqual([]);+ });+});diff --git a/packages/twenty-server/src/engine/twenty-orm/utils/__tests__/resolve-inherited-readability-parents.util.spec.ts b/packages/twenty-server/src/engine/twenty-orm/utils/__tests__/resolve-inherited-readability-parents.util.spec.tsindex 81c648518c7..a2dd02ba1b8 100644--- a/packages/twenty-server/src/engine/twenty-orm/utils/__tests__/resolve-inherited-readability-parents.util.spec.ts+++ b/packages/twenty-server/src/engine/twenty-orm/utils/__tests__/resolve-inherited-readability-parents.util.spec.ts@@ -1,4 +1,4 @@-import { FieldMetadataType } from 'twenty-shared/types';+import { FieldMetadataType, MetadataReadability } from 'twenty-shared/types';import { RelationType } from 'src/engine/metadata-modules/field-metadata/interfaces/relation-type.interface';@@ -15,6 +15,8 @@ const PERSON_OBJECT_ID = 'person-object-id';const WORKSPACE_MEMBER_OBJECT_ID = 'workspace-member-object-id';const TARGET_MORPH_ID = 'target-morph-id';const OTHER_MORPH_ID = 'other-morph-id';+const NOTE_ATTACHMENTS_FIELD_ID = 'note-attachments-field-id';+const TARGET_NOTE_FIELD_ID = 'target-note-field-id';const buildManyToOneField = ({id,@@ -22,6 +24,7 @@ const buildManyToOneField = ({type,objectMetadataId,relationTargetObjectMetadataId,+ relationTargetFieldMetadataId,morphId,}: {id: string;@@ -29,6 +32,7 @@ const buildManyToOneField = ({type: FieldMetadataType.RELATION | FieldMetadataType.MORPH_RELATION;objectMetadataId: string;relationTargetObjectMetadataId: string;+ relationTargetFieldMetadataId?: string;morphId?: string;}) =>getFlatFieldMetadataMock({@@ -38,6 +42,7 @@ const buildManyToOneField = ({universalIdentifier: `${id}-universal-identifier`,objectMetadataId,relationTargetObjectMetadataId,+ relationTargetFieldMetadataId: relationTargetFieldMetadataId ?? null,morphId: morphId ?? null,settings: {relationType: RelationType.MANY_TO_ONE,@@ -46,11 +51,12 @@ const buildManyToOneField = ({} as Parameters<typeof getFlatFieldMetadataMock>[0]);const targetNoteField = buildManyToOneField({- id: 'target-note-field-id',+ id: TARGET_NOTE_FIELD_ID,name: 'targetNote',type: FieldMetadataType.MORPH_RELATION,objectMetadataId: ATTACHMENT_OBJECT_ID,relationTargetObjectMetadataId: NOTE_OBJECT_ID,+ relationTargetFieldMetadataId: NOTE_ATTACHMENTS_FIELD_ID,morphId: TARGET_MORPH_ID,});@@ -81,12 +87,13 @@ const authorField = buildManyToOneField({});const noteAttachmentsField = getFlatFieldMetadataMock({- id: 'note-attachments-field-id',+ id: NOTE_ATTACHMENTS_FIELD_ID,name: 'attachments',type: FieldMetadataType.RELATION,- universalIdentifier: 'note-attachments-field-id-universal-identifier',+ universalIdentifier: `${NOTE_ATTACHMENTS_FIELD_ID}-universal-identifier`,objectMetadataId: NOTE_OBJECT_ID,relationTargetObjectMetadataId: ATTACHMENT_OBJECT_ID,+ relationTargetFieldMetadataId: TARGET_NOTE_FIELD_ID,settings: { relationType: RelationType.ONE_TO_MANY },} as Parameters<typeof getFlatFieldMetadataMock>[0]);@@ -129,13 +136,42 @@ const buildFlatEntityMaps = <T extends FlatFieldMetadata | FlatObjectMetadata>(universalIdentifiersByApplicationId: {},});-const buildObjectMetadataMaps = () =>+const buildAttachmentObject = (+ readabilityParentFieldUniversalIdentifiers: string[] | null,+) =>+ getFlatObjectMetadataMock({+ id: ATTACHMENT_OBJECT_ID,+ universalIdentifier: 'attachment-object-universal-identifier',+ nameSingular: 'attachment',+ fieldIds: attachmentFields.map((field) => field.id),+ readabilityParentFieldUniversalIdentifiers,+ });++const buildNoteObject = ({+ readability,+ readabilityParentFieldUniversalIdentifiers,+}: {+ readability: MetadataReadability;+ readabilityParentFieldUniversalIdentifiers: string[] | null;+}) =>+ getFlatObjectMetadataMock({+ id: NOTE_OBJECT_ID,+ universalIdentifier: 'note-object-universal-identifier',+ nameSingular: 'note',+ fieldIds: [noteAttachmentsField.id],+ readability,+ readabilityParentFieldUniversalIdentifiers,+ });++const buildObjectMetadataMaps = ({+ noteFlatObjectMetadata = buildNoteObject({+ readability: MetadataReadability.OPEN,+ readabilityParentFieldUniversalIdentifiers: null,+ }),+}: { noteFlatObjectMetadata?: FlatObjectMetadata } = {}) =>buildFlatEntityMaps([- getFlatObjectMetadataMock({- id: NOTE_OBJECT_ID,- universalIdentifier: 'note-object-universal-identifier',- nameSingular: 'note',- }),+ buildAttachmentObject(null),+ noteFlatObjectMetadata,getFlatObjectMetadataMock({id: PERSON_OBJECT_ID,universalIdentifier: 'person-object-universal-identifier',@@ -148,39 +184,88 @@ const buildObjectMetadataMaps = () =>}),]);-const resolve = (readabilityParentFieldUniversalIdentifiers: string[]) =>+const describeParent = (+ parent: ReturnType<typeof resolveInheritedReadabilityParents>[number],+) =>+ parent.kind === 'column'+ ? {+ kind: parent.kind,+ joinColumnName: parent.joinColumnName,+ parentNameSingular: parent.parentFlatObjectMetadata.nameSingular,+ }+ : {+ kind: parent.kind,+ childJoinColumnName: parent.childJoinColumnName,+ childNameSingular: parent.childFlatObjectMetadata.nameSingular,+ };++const resolveForAttachment = (+ readabilityParentFieldUniversalIdentifiers: string[],+) =>resolveInheritedReadabilityParents({- flatObjectMetadata: getFlatObjectMetadataMock({- id: ATTACHMENT_OBJECT_ID,- universalIdentifier: 'attachment-object-universal-identifier',- nameSingular: 'attachment',- fieldIds: attachmentFields.map((field) => field.id),+ flatObjectMetadata: buildAttachmentObject(readabilityParentFieldUniversalIdentifiers,- }),+ ),flatFieldMetadataMaps: buildFlatEntityMaps(allFields),flatObjectMetadataMaps: buildObjectMetadataMaps(),- }).map(({ joinColumnName, parentFlatObjectMetadata }) => ({- joinColumnName,- parentNameSingular: parentFlatObjectMetadata.nameSingular,- }));+ }).map(describeParent);describe('resolveInheritedReadabilityParents', () => {it('should resolve a declared plain relation field to its join column and parent', () => {- expect(resolve([authorField.universalIdentifier])).toEqual([- { joinColumnName: 'authorId', parentNameSingular: 'workspaceMember' },+ expect(resolveForAttachment([authorField.universalIdentifier])).toEqual([+ {+ kind: 'column',+ joinColumnName: 'authorId',+ parentNameSingular: 'workspaceMember',+ },]);});it('should expand a declared morph relation field to every field sharing its morph id', () => {- expect(resolve([targetNoteField.universalIdentifier])).toEqual([- { joinColumnName: 'targetNoteId', parentNameSingular: 'note' },- { joinColumnName: 'targetPersonId', parentNameSingular: 'person' },+ expect(resolveForAttachment([targetNoteField.universalIdentifier])).toEqual(+ [+ {+ kind: 'column',+ joinColumnName: 'targetNoteId',+ parentNameSingular: 'note',+ },+ {+ kind: 'column',+ joinColumnName: 'targetPersonId',+ parentNameSingular: 'person',+ },+ ],+ );+ });++ it('should resolve a declared one-to-many field to the child object and its join column', () => {+ const noteFlatObjectMetadata = buildNoteObject({+ readability: MetadataReadability.INHERITED,+ readabilityParentFieldUniversalIdentifiers: [+ noteAttachmentsField.universalIdentifier,+ ],+ });++ expect(+ resolveInheritedReadabilityParents({+ flatObjectMetadata: noteFlatObjectMetadata,+ flatFieldMetadataMaps: buildFlatEntityMaps(allFields),+ flatObjectMetadataMaps: buildObjectMetadataMaps({+ noteFlatObjectMetadata,+ }),+ }).map(describeParent),+ ).toEqual([+ {+ kind: 'children',+ childJoinColumnName: 'targetNoteId',+ childNameSingular: 'attachment',+ },]);});- it('should ignore declared fields that are not to-one relations of the object', () => {+ it('should ignore declared fields that are not relations of the object', () => {expect(- resolve([+ resolveForAttachment([nameField.universalIdentifier,noteAttachmentsField.universalIdentifier,'unknown-universal-identifier',@@ -191,12 +276,7 @@ describe('resolveInheritedReadabilityParents', () => {it('should resolve nothing when no parent field is declared', () => {expect(resolveInheritedReadabilityParents({- flatObjectMetadata: getFlatObjectMetadataMock({- id: ATTACHMENT_OBJECT_ID,- universalIdentifier: 'attachment-object-universal-identifier',- fieldIds: attachmentFields.map((field) => field.id),- readabilityParentFieldUniversalIdentifiers: null,- }),+ flatObjectMetadata: buildAttachmentObject(null),flatFieldMetadataMaps: buildFlatEntityMaps(allFields),flatObjectMetadataMaps: buildObjectMetadataMaps(),}),diff --git a/packages/twenty-server/src/engine/twenty-orm/utils/build-inherited-readability-condition.util.ts b/packages/twenty-server/src/engine/twenty-orm/utils/build-inherited-readability-condition.util.tsindex 1f6e5a133c5..63dcf5b8376 100644--- a/packages/twenty-server/src/engine/twenty-orm/utils/build-inherited-readability-condition.util.ts+++ b/packages/twenty-server/src/engine/twenty-orm/utils/build-inherited-readability-condition.util.ts@@ -4,6 +4,8 @@ import { type ObjectLiteral } from 'typeorm';import { buildRecordShareCondition } from 'src/engine/twenty-orm/utils/build-record-share-condition.util';import { escapeIdentifier } from 'src/engine/workspace-manager/workspace-migration/utils/remove-sql-injection.util';+type SqlCondition = { sql: string; parameters: ObjectLiteral };+export type InheritedReadabilityParentGate =| { kind: 'open' }| { kind: 'denied' }@@ -12,13 +14,27 @@ export type InheritedReadabilityParentGate =kind: 'inherited';parentTableAlias: string;parentTableExpression: string;- parentCondition: { sql: string; parameters: ObjectLiteral };+ parentCondition: SqlCondition;};-export type InheritedReadabilityParentCondition = {- joinColumnName: string;- gate: InheritedReadabilityParentGate;-};+export type InheritedReadabilityChildGate =+ | { kind: 'open' }+ | { kind: 'denied' }+ | { kind: 'gated'; condition: SqlCondition };++export type InheritedReadabilityParentCondition =+ | {+ kind: 'column';+ joinColumnName: string;+ gate: InheritedReadabilityParentGate;+ }+ | {+ kind: 'children';+ childTableAlias: string;+ childTableExpression: string;+ childJoinColumnName: string;+ gate: InheritedReadabilityChildGate;+ };export const buildInheritedReadabilityCondition = ({tableAlias,@@ -34,7 +50,7 @@ export const buildInheritedReadabilityCondition = ({recordShareTableExpression: string;principalIds: string[];accessLevels: RecordShareAccessLevel[];-}): { sql: string; parameters: ObjectLiteral } | undefined => {+}): SqlCondition | undefined => {const parameters: ObjectLiteral = {};const quotedTableAlias = escapeIdentifier(tableAlias);const quoteColumn = (joinColumnName: string) =>@@ -52,7 +68,36 @@ export const buildInheritedReadabilityCondition = ({Object.assign(parameters, ownRecordShareCondition.parameters);- const parentConditions = parents.flatMap(({ joinColumnName, gate }) => {+ const parentConditions = parents.flatMap((parent) => {+ if (parent.kind === 'children') {+ const {+ childTableAlias,+ childTableExpression,+ childJoinColumnName,+ gate,+ } = parent;++ if (gate.kind === 'denied') {+ return [];+ }++ const quotedChildTableAlias = escapeIdentifier(childTableAlias);+ const childRowConditions = [+ `${quotedChildTableAlias}.${escapeIdentifier(childJoinColumnName)} = ${quotedTableAlias}."id"`,+ `${quotedChildTableAlias}."deletedAt" IS NULL`,+ ];++ if (gate.kind === 'gated') {+ Object.assign(parameters, gate.condition.parameters);+ childRowConditions.push(gate.condition.sql);+ }++ return [+ `EXISTS (SELECT 1 FROM ${childTableExpression} AS ${quotedChildTableAlias} WHERE ${childRowConditions.join(' AND ')})`,+ ];+ }++ const { joinColumnName, gate } = parent;const notNullCondition = `${quoteColumn(joinColumnName)} IS NOT NULL`;switch (gate.kind) {diff --git a/packages/twenty-server/src/engine/twenty-orm/utils/get-relation-flat-field-metadatas-of-object.util.ts b/packages/twenty-server/src/engine/twenty-orm/utils/get-relation-flat-field-metadatas-of-object.util.tsnew file mode 100644index 00000000000..e8f2a0979c4--- /dev/null+++ b/packages/twenty-server/src/engine/twenty-orm/utils/get-relation-flat-field-metadatas-of-object.util.ts@@ -0,0 +1,33 @@+import { isDefined } from 'twenty-shared/utils';++import { getFlatFieldsFromFlatObjectMetadata } from 'src/engine/api/graphql/workspace-schema-builder/utils/get-flat-fields-for-flat-object-metadata.util';+import { type MorphOrRelationFieldMetadataType } from 'src/engine/metadata-modules/field-metadata/types/morph-or-relation-field-metadata-type.type';+import { type FlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/flat-entity-maps.type';+import { type OrmFlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/types/orm-flat-field-metadata.type';+import { isMorphOrRelationFlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/utils/is-morph-or-relation-flat-field-metadata.util';+import { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';++export const getRelationFlatFieldMetadatasOfObject = ({+ flatObjectMetadata,+ flatFieldMetadataMaps,+}: {+ flatObjectMetadata: FlatObjectMetadata;+ flatFieldMetadataMaps: FlatEntityMaps<OrmFlatFieldMetadata>;+}): OrmFlatFieldMetadata<MorphOrRelationFieldMetadataType>[] => {+ const flatFieldMetadatas =+ flatObjectMetadata.fieldIds.length > 0+ ? getFlatFieldsFromFlatObjectMetadata(+ flatObjectMetadata,+ flatFieldMetadataMaps,+ )+ : Object.values(flatFieldMetadataMaps.byUniversalIdentifier);++ return flatFieldMetadatas.filter(+ (+ flatFieldMetadata,+ ): flatFieldMetadata is OrmFlatFieldMetadata<MorphOrRelationFieldMetadataType> =>+ isDefined(flatFieldMetadata) &&+ flatFieldMetadata.objectMetadataId === flatObjectMetadata.id &&+ isMorphOrRelationFlatFieldMetadata(flatFieldMetadata),+ );+};diff --git a/packages/twenty-server/src/engine/twenty-orm/utils/is-many-to-one-flat-field-metadata.util.ts b/packages/twenty-server/src/engine/twenty-orm/utils/is-many-to-one-flat-field-metadata.util.tsnew file mode 100644index 00000000000..a20a6001649--- /dev/null+++ b/packages/twenty-server/src/engine/twenty-orm/utils/is-many-to-one-flat-field-metadata.util.ts@@ -0,0 +1,9 @@+import { RelationType } from 'src/engine/metadata-modules/field-metadata/interfaces/relation-type.interface';++import { type MorphOrRelationFieldMetadataType } from 'src/engine/metadata-modules/field-metadata/types/morph-or-relation-field-metadata-type.type';+import { type OrmFlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/types/orm-flat-field-metadata.type';++export const isManyToOneFlatFieldMetadata = (+ flatFieldMetadata: OrmFlatFieldMetadata<MorphOrRelationFieldMetadataType>,+): boolean =>+ flatFieldMetadata.settings?.relationType === RelationType.MANY_TO_ONE;diff --git a/packages/twenty-server/src/engine/twenty-orm/utils/resolve-inherited-readability-child-links.util.ts b/packages/twenty-server/src/engine/twenty-orm/utils/resolve-inherited-readability-child-links.util.tsnew file mode 100644index 00000000000..c56f450f9f4--- /dev/null+++ b/packages/twenty-server/src/engine/twenty-orm/utils/resolve-inherited-readability-child-links.util.ts@@ -0,0 +1,60 @@+import { MetadataReadability } from 'twenty-shared/types';+import { isDefined } from 'twenty-shared/utils';++import { computeMorphOrRelationFieldJoinColumnName } from 'src/engine/metadata-modules/field-metadata/utils/compute-morph-or-relation-field-join-column-name.util';+import { type FlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/flat-entity-maps.type';+import { findFlatEntityByIdInFlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/utils/find-flat-entity-by-id-in-flat-entity-maps.util';+import { type OrmFlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/types/orm-flat-field-metadata.type';+import { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';+import { type InheritedReadabilityParentLink } from 'src/engine/twenty-orm/types/inherited-readability-parent-link.type';+import { getRelationFlatFieldMetadatasOfObject } from 'src/engine/twenty-orm/utils/get-relation-flat-field-metadatas-of-object.util';+import { isManyToOneFlatFieldMetadata } from 'src/engine/twenty-orm/utils/is-many-to-one-flat-field-metadata.util';++// The records of other objects that inherit their readability through the rows+// of this object: writing such a row grants access to the record it points at+export const resolveInheritedReadabilityChildLinks = ({+ flatObjectMetadata,+ flatFieldMetadataMaps,+ flatObjectMetadataMaps,+}: {+ flatObjectMetadata: FlatObjectMetadata;+ flatFieldMetadataMaps: FlatEntityMaps<OrmFlatFieldMetadata>;+ flatObjectMetadataMaps: FlatEntityMaps<FlatObjectMetadata>;+}): InheritedReadabilityParentLink[] =>+ getRelationFlatFieldMetadatasOfObject({+ flatObjectMetadata,+ flatFieldMetadataMaps,+ })+ .filter(isManyToOneFlatFieldMetadata)+ .flatMap((flatFieldMetadata) => {+ const parentFlatObjectMetadata = findFlatEntityByIdInFlatEntityMaps({+ flatEntityMaps: flatObjectMetadataMaps,+ flatEntityId: flatFieldMetadata.relationTargetObjectMetadataId,+ });+ const parentFlatFieldMetadata = findFlatEntityByIdInFlatEntityMaps({+ flatEntityMaps: flatFieldMetadataMaps,+ flatEntityId: flatFieldMetadata.relationTargetFieldMetadataId,+ });++ if (+ !isDefined(parentFlatObjectMetadata) ||+ !isDefined(parentFlatFieldMetadata) ||+ parentFlatObjectMetadata.readability !==+ MetadataReadability.INHERITED ||+ !(+ parentFlatObjectMetadata.readabilityParentFieldUniversalIdentifiers ??+ []+ ).includes(parentFlatFieldMetadata.universalIdentifier)+ ) {+ return [];+ }++ return [+ {+ joinColumnName: computeMorphOrRelationFieldJoinColumnName({+ name: flatFieldMetadata.name,+ }),+ parentFlatObjectMetadata,+ },+ ];+ });diff --git a/packages/twenty-server/src/engine/twenty-orm/utils/resolve-inherited-readability-parents.util.ts b/packages/twenty-server/src/engine/twenty-orm/utils/resolve-inherited-readability-parents.util.tsindex 8095c9c8ab9..343768109a4 100644--- a/packages/twenty-server/src/engine/twenty-orm/utils/resolve-inherited-readability-parents.util.ts+++ b/packages/twenty-server/src/engine/twenty-orm/utils/resolve-inherited-readability-parents.util.ts@@ -3,7 +3,6 @@ import { isDefined } from 'twenty-shared/utils';import { RelationType } from 'src/engine/metadata-modules/field-metadata/interfaces/relation-type.interface';-import { getFlatFieldsFromFlatObjectMetadata } from 'src/engine/api/graphql/workspace-schema-builder/utils/get-flat-fields-for-flat-object-metadata.util';import { type MorphOrRelationFieldMetadataType } from 'src/engine/metadata-modules/field-metadata/types/morph-or-relation-field-metadata-type.type';import { computeMorphOrRelationFieldJoinColumnName } from 'src/engine/metadata-modules/field-metadata/utils/compute-morph-or-relation-field-join-column-name.util';import { type FlatEntityMaps } from 'src/engine/metadata-modules/flat-entity/types/flat-entity-maps.type';@@ -11,57 +10,33 @@ import { findFlatEntityByIdInFlatEntityMaps } from 'src/engine/metadata-modules/import { type OrmFlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/types/orm-flat-field-metadata.type';import { isMorphOrRelationFlatFieldMetadata } from 'src/engine/metadata-modules/flat-field-metadata/utils/is-morph-or-relation-flat-field-metadata.util';import { type FlatObjectMetadata } from 'src/engine/metadata-modules/flat-object-metadata/types/flat-object-metadata.type';+import { type InheritedReadabilityChildrenParent } from 'src/engine/twenty-orm/types/inherited-readability-children-parent.type';+import { type InheritedReadabilityColumnParent } from 'src/engine/twenty-orm/types/inherited-readability-column-parent.type';+import { type InheritedReadabilityParent } from 'src/engine/twenty-orm/types/inherited-readability-parent.type';+import { getRelationFlatFieldMetadatasOfObject } from 'src/engine/twenty-orm/utils/get-relation-flat-field-metadatas-of-object.util';+import { isManyToOneFlatFieldMetadata } from 'src/engine/twenty-orm/utils/is-many-to-one-flat-field-metadata.util';-export type InheritedReadabilityParent = {- fieldMetadataId: string;- joinColumnName: string;- parentFlatObjectMetadata: FlatObjectMetadata;-};+type RelationFlatFieldMetadata =+ OrmFlatFieldMetadata<MorphOrRelationFieldMetadataType>;-const isManyToOneFieldOfObject =- (flatObjectMetadata: FlatObjectMetadata) =>- (- flatFieldMetadata: OrmFlatFieldMetadata | undefined,- ): flatFieldMetadata is OrmFlatFieldMetadata<MorphOrRelationFieldMetadataType> =>- isDefined(flatFieldMetadata) &&- flatFieldMetadata.objectMetadataId === flatObjectMetadata.id &&- isMorphOrRelationFlatFieldMetadata(flatFieldMetadata) &&- flatFieldMetadata.settings?.relationType === RelationType.MANY_TO_ONE;--const getObjectFlatFieldMetadatas = ({- flatObjectMetadata,- flatFieldMetadataMaps,-}: {- flatObjectMetadata: FlatObjectMetadata;- flatFieldMetadataMaps: FlatEntityMaps<OrmFlatFieldMetadata>;-}): (OrmFlatFieldMetadata | undefined)[] =>- flatObjectMetadata.fieldIds.length > 0- ? getFlatFieldsFromFlatObjectMetadata(- flatObjectMetadata,- flatFieldMetadataMaps,- )- : Object.values(flatFieldMetadataMaps.byUniversalIdentifier);+const isOneToMany = (flatFieldMetadata: RelationFlatFieldMetadata): boolean =>+ flatFieldMetadata.settings?.relationType === RelationType.ONE_TO_MANY;-export const resolveInheritedReadabilityParents = ({- flatObjectMetadata,- flatFieldMetadataMaps,+const resolveColumnParents = ({+ relationFlatFieldMetadatas,+ declaredFlatFieldMetadatas,flatObjectMetadataMaps,}: {- flatObjectMetadata: FlatObjectMetadata;- flatFieldMetadataMaps: FlatEntityMaps<OrmFlatFieldMetadata>;+ relationFlatFieldMetadatas: RelationFlatFieldMetadata[];+ declaredFlatFieldMetadatas: RelationFlatFieldMetadata[];flatObjectMetadataMaps: FlatEntityMaps<FlatObjectMetadata>;-}): InheritedReadabilityParent[] => {- const declaredFlatFieldMetadatas = (- flatObjectMetadata.readabilityParentFieldUniversalIdentifiers ?? []- )- .map(- (universalIdentifier) =>- flatFieldMetadataMaps.byUniversalIdentifier[universalIdentifier],- )- .filter(isManyToOneFieldOfObject(flatObjectMetadata));+}): InheritedReadabilityColumnParent[] => {+ const declaredManyToOneFlatFieldMetadatas = declaredFlatFieldMetadatas.filter(+ isManyToOneFlatFieldMetadata,+ );const declaredMorphIds = new Set(- declaredFlatFieldMetadatas+ declaredManyToOneFlatFieldMetadatas.filter((flatFieldMetadata) =>flatFieldMetadata.type === FieldMetadataType.MORPH_RELATION,@@ -70,23 +45,17 @@ export const resolveInheritedReadabilityParents = ({.filter(isDefined),);- const morphSiblingFlatFieldMetadatas =- declaredMorphIds.size === 0- ? []- : getObjectFlatFieldMetadatas({- flatObjectMetadata,- flatFieldMetadataMaps,- })- .filter(isManyToOneFieldOfObject(flatObjectMetadata))- .filter(- (flatFieldMetadata) =>- flatFieldMetadata.type === FieldMetadataType.MORPH_RELATION &&- isDefined(flatFieldMetadata.morphId) &&- declaredMorphIds.has(flatFieldMetadata.morphId),- );+ const morphSiblingFlatFieldMetadatas = relationFlatFieldMetadatas+ .filter(isManyToOneFlatFieldMetadata)+ .filter(+ (flatFieldMetadata) =>+ flatFieldMetadata.type === FieldMetadataType.MORPH_RELATION &&+ isDefined(flatFieldMetadata.morphId) &&+ declaredMorphIds.has(flatFieldMetadata.morphId),+ );const parentFlatFieldMetadatas = [- ...declaredFlatFieldMetadatas,+ ...declaredManyToOneFlatFieldMetadatas,...morphSiblingFlatFieldMetadatas,].filter((flatFieldMetadata, index, flatFieldMetadatas) =>@@ -107,6 +76,7 @@ export const resolveInheritedReadabilityParents = ({return [{+ kind: 'column' as const,fieldMetadataId: flatFieldMetadata.id,joinColumnName: computeMorphOrRelationFieldJoinColumnName({name: flatFieldMetadata.name,@@ -116,3 +86,81 @@ export const resolveInheritedReadabilityParents = ({];});};++const resolveChildrenParents = ({+ declaredFlatFieldMetadatas,+ flatFieldMetadataMaps,+ flatObjectMetadataMaps,+}: {+ declaredFlatFieldMetadatas: RelationFlatFieldMetadata[];+ flatFieldMetadataMaps: FlatEntityMaps<OrmFlatFieldMetadata>;+ flatObjectMetadataMaps: FlatEntityMaps<FlatObjectMetadata>;+}): InheritedReadabilityChildrenParent[] =>+ declaredFlatFieldMetadatas+ .filter(isOneToMany)+ .flatMap((flatFieldMetadata) => {+ const childFlatObjectMetadata = findFlatEntityByIdInFlatEntityMaps({+ flatEntityMaps: flatObjectMetadataMaps,+ flatEntityId: flatFieldMetadata.relationTargetObjectMetadataId,+ });+ const childFlatFieldMetadata = findFlatEntityByIdInFlatEntityMaps({+ flatEntityMaps: flatFieldMetadataMaps,+ flatEntityId: flatFieldMetadata.relationTargetFieldMetadataId,+ });++ if (+ !isDefined(childFlatObjectMetadata) ||+ !isDefined(childFlatFieldMetadata) ||+ !isMorphOrRelationFlatFieldMetadata(childFlatFieldMetadata) ||+ !isManyToOneFlatFieldMetadata(childFlatFieldMetadata)+ ) {+ return [];+ }++ return [+ {+ kind: 'children' as const,+ fieldMetadataId: flatFieldMetadata.id,+ childJoinColumnName: computeMorphOrRelationFieldJoinColumnName({+ name: childFlatFieldMetadata.name,+ }),+ childFlatObjectMetadata,+ },+ ];+ });++export const resolveInheritedReadabilityParents = ({+ flatObjectMetadata,+ flatFieldMetadataMaps,+ flatObjectMetadataMaps,+}: {+ flatObjectMetadata: FlatObjectMetadata;+ flatFieldMetadataMaps: FlatEntityMaps<OrmFlatFieldMetadata>;+ flatObjectMetadataMaps: FlatEntityMaps<FlatObjectMetadata>;+}): InheritedReadabilityParent[] => {+ const relationFlatFieldMetadatas = getRelationFlatFieldMetadatasOfObject({+ flatObjectMetadata,+ flatFieldMetadataMaps,+ });+ const declaredFlatFieldMetadatas = (+ flatObjectMetadata.readabilityParentFieldUniversalIdentifiers ?? []+ ).flatMap((universalIdentifier) =>+ relationFlatFieldMetadatas.filter(+ (flatFieldMetadata) =>+ flatFieldMetadata.universalIdentifier === universalIdentifier,+ ),+ );++ return [+ ...resolveColumnParents({+ relationFlatFieldMetadatas,+ declaredFlatFieldMetadatas,+ flatObjectMetadataMaps,+ }),+ ...resolveChildrenParents({+ declaredFlatFieldMetadatas,+ flatFieldMetadataMaps,+ flatObjectMetadataMaps,+ }),+ ];+};diff --git a/packages/twenty-server/src/engine/workspace-manager/twenty-standard-application/utils/__tests__/standard-object-readability.spec.ts b/packages/twenty-server/src/engine/workspace-manager/twenty-standard-application/utils/__tests__/standard-object-readability.spec.tsindex 52c4cc5e60e..00be0049a58 100644--- a/packages/twenty-server/src/engine/workspace-manager/twenty-standard-application/utils/__tests__/standard-object-readability.spec.ts+++ b/packages/twenty-server/src/engine/workspace-manager/twenty-standard-application/utils/__tests__/standard-object-readability.spec.ts@@ -16,8 +16,10 @@ const NOW = '2024-01-01T00:00:00.000Z';const INHERITED_STANDARD_OBJECT_PARENT_FIELDS = {attachment: STANDARD_OBJECT_FIELDS.attachment.targetNote,timelineActivity: STANDARD_OBJECT_FIELDS.timelineActivity.targetPerson,- noteTarget: STANDARD_OBJECT_FIELDS.noteTarget.note,- taskTarget: STANDARD_OBJECT_FIELDS.taskTarget.task,+ note: STANDARD_OBJECT_FIELDS.note.noteTargets,+ noteTarget: STANDARD_OBJECT_FIELDS.noteTarget.targetPerson,+ task: STANDARD_OBJECT_FIELDS.task.taskTargets,+ taskTarget: STANDARD_OBJECT_FIELDS.taskTarget.targetPerson,messageThreadTarget: STANDARD_OBJECT_FIELDS.messageThreadTarget.messageThread,calendarEventTarget: STANDARD_OBJECT_FIELDS.calendarEventTarget.calendarEvent,} as const;@@ -43,6 +45,18 @@ describe('Standard object readability', () => {STANDARD_OBJECTS[objectName].universalIdentifier,);+ const resolveParents = (objectName: keyof typeof STANDARD_OBJECTS) => {+ const flatObjectMetadata = findStandardFlatObjectMetadata(objectName);++ expect(flatObjectMetadata).toBeDefined();++ return resolveInheritedReadabilityParents({+ flatObjectMetadata: flatObjectMetadata!,+ flatFieldMetadataMaps: allFlatEntityMaps.flatFieldMetadataMaps,+ flatObjectMetadataMaps: allFlatEntityMaps.flatObjectMetadataMaps,+ });+ };+const inheritedObjectNames = Object.keys(INHERITED_STANDARD_OBJECT_PARENT_FIELDS,) as (keyof typeof INHERITED_STANDARD_OBJECT_PARENT_FIELDS)[];@@ -82,17 +96,8 @@ describe('Standard object readability', () => {);it('resolves every attachment target as a parent of attachment', () => {- const attachmentFlatObjectMetadata =- findStandardFlatObjectMetadata('attachment');-- expect(attachmentFlatObjectMetadata).toBeDefined();-- const parentJoinColumnNames = resolveInheritedReadabilityParents({- flatObjectMetadata: attachmentFlatObjectMetadata!,- flatFieldMetadataMaps: allFlatEntityMaps.flatFieldMetadataMaps,- flatObjectMetadataMaps: allFlatEntityMaps.flatObjectMetadataMaps,- })- .map(({ joinColumnName }) => joinColumnName)+ const parentJoinColumnNames = resolveParents('attachment')+ .map((parent) => (parent.kind === 'column' ? parent.joinColumnName : '')).sort();expect(parentJoinColumnNames).toEqual(@@ -108,22 +113,60 @@ describe('Standard object readability', () => {);});- it('resolves the note as the only parent of noteTarget', () => {- const noteTargetFlatObjectMetadata =- findStandardFlatObjectMetadata('noteTarget');+ it('resolves every target of a noteTarget as its parent, not the note', () => {+ const parents = resolveParents('noteTarget').map((parent) =>+ parent.kind === 'column'+ ? {+ joinColumnName: parent.joinColumnName,+ parentNameSingular: parent.parentFlatObjectMetadata.nameSingular,+ }+ : parent.kind,+ );- expect(noteTargetFlatObjectMetadata).toBeDefined();+ expect(parents).toEqual(+ expect.arrayContaining([+ { joinColumnName: 'targetPersonId', parentNameSingular: 'person' },+ { joinColumnName: 'targetCompanyId', parentNameSingular: 'company' },+ {+ joinColumnName: 'targetOpportunityId',+ parentNameSingular: 'opportunity',+ },+ ]),+ );+ expect(parents).not.toContainEqual({+ joinColumnName: 'noteId',+ parentNameSingular: 'note',+ });+ });+ it('resolves its note targets as the parents of a note, through the noteId column', () => {expect(- resolveInheritedReadabilityParents({- flatObjectMetadata: noteTargetFlatObjectMetadata!,- flatFieldMetadataMaps: allFlatEntityMaps.flatFieldMetadataMaps,- flatObjectMetadataMaps: allFlatEntityMaps.flatObjectMetadataMaps,- }).map(({ joinColumnName, parentFlatObjectMetadata }) => ({- joinColumnName,- parentNameSingular: parentFlatObjectMetadata.nameSingular,- })),- ).toEqual([{ joinColumnName: 'noteId', parentNameSingular: 'note' }]);+ resolveParents('note').map((parent) =>+ parent.kind === 'children'+ ? {+ childNameSingular: parent.childFlatObjectMetadata.nameSingular,+ childJoinColumnName: parent.childJoinColumnName,+ }+ : parent.kind,+ ),+ ).toEqual([+ { childNameSingular: 'noteTarget', childJoinColumnName: 'noteId' },+ ]);+ });++ it('resolves its task targets as the parents of a task, through the taskId column', () => {+ expect(+ resolveParents('task').map((parent) =>+ parent.kind === 'children'+ ? {+ childNameSingular: parent.childFlatObjectMetadata.nameSingular,+ childJoinColumnName: parent.childJoinColumnName,+ }+ : parent.kind,+ ),+ ).toEqual([+ { childNameSingular: 'taskTarget', childJoinColumnName: 'taskId' },+ ]);});it('leaves every other standard object OPEN for readability', () => {diff --git a/packages/twenty-server/src/engine/workspace-manager/twenty-standard-application/utils/object-metadata/create-standard-flat-object-metadata.util.ts b/packages/twenty-server/src/engine/workspace-manager/twenty-standard-application/utils/object-metadata/create-standard-flat-object-metadata.util.tsindex 8541c2ed585..ae9bef48651 100644--- a/packages/twenty-server/src/engine/workspace-manager/twenty-standard-application/utils/object-metadata/create-standard-flat-object-metadata.util.ts+++ b/packages/twenty-server/src/engine/workspace-manager/twenty-standard-application/utils/object-metadata/create-standard-flat-object-metadata.util.ts@@ -829,6 +829,8 @@ export const STANDARD_FLAT_OBJECT_METADATA_BUILDERS_BY_OBJECT_NAME = {icon: 'IconNotes',isSearchable: true,shortcut: 'N',+ readability: MetadataReadability.INHERITED,+ readabilityParentFieldMetadataNames: ['noteTargets'],labelIdentifierFieldMetadataName: 'title',},workspaceId,@@ -872,7 +874,7 @@ export const STANDARD_FLAT_OBJECT_METADATA_BUILDERS_BY_OBJECT_NAME = {isSystem: true,isUICreatable: false,readability: MetadataReadability.INHERITED,- readabilityParentFieldMetadataNames: ['note'],+ readabilityParentFieldMetadataNames: ['targetPerson'],labelIdentifierFieldMetadataName: 'id',},workspaceId,@@ -1034,6 +1036,8 @@ export const STANDARD_FLAT_OBJECT_METADATA_BUILDERS_BY_OBJECT_NAME = {icon: 'IconCheckbox',isSearchable: true,shortcut: 'T',+ readability: MetadataReadability.INHERITED,+ readabilityParentFieldMetadataNames: ['taskTargets'],labelIdentifierFieldMetadataName: 'title',},workspaceId,@@ -1077,7 +1081,7 @@ export const STANDARD_FLAT_OBJECT_METADATA_BUILDERS_BY_OBJECT_NAME = {isSystem: true,isUICreatable: false,readability: MetadataReadability.INHERITED,- readabilityParentFieldMetadataNames: ['task'],+ readabilityParentFieldMetadataNames: ['targetPerson'],labelIdentifierFieldMetadataName: 'id',},workspaceId,diff --git a/packages/twenty-server/test/integration/graphql/suites/object-records-permissions/inherited-readability-object-records-permissions.integration-spec.ts b/packages/twenty-server/test/integration/graphql/suites/object-records-permissions/inherited-readability-object-records-permissions.integration-spec.tsindex 6f50131820b..7e5f931cf20 100644--- a/packages/twenty-server/test/integration/graphql/suites/object-records-permissions/inherited-readability-object-records-permissions.integration-spec.ts+++ b/packages/twenty-server/test/integration/graphql/suites/object-records-permissions/inherited-readability-object-records-permissions.integration-spec.ts@@ -186,7 +186,11 @@ describe('inheritedReadabilityObjectRecordsPermissions', () => {},{objectMetadataSingularName: 'noteTarget',- data: { id: NOTE_TARGET_ID, noteId: NOTE_ID },+ data: {+ id: NOTE_TARGET_ID,+ noteId: NOTE_ID,+ targetPersonId: PERSON_ID,+ },},];@@ -220,7 +224,10 @@ describe('inheritedReadabilityObjectRecordsPermissions', () => {objectMetadataId: attachmentObjectMetadataId,recordIds: ATTACHMENT_IDS,});- await setObjectReadability(noteObjectMetadataId, MetadataReadability.OPEN);+ await setObjectReadability(+ noteObjectMetadataId,+ MetadataReadability.INHERITED,+ );await destroyRecords({objectMetadataSingularName: 'attachment',objectMetadataPluralName: 'attachments',@@ -274,7 +281,7 @@ describe('inheritedReadabilityObjectRecordsPermissions', () => {});describe('without a share row on the note', () => {- it('should hide the attachment and the note target hanging off the note', async () => {+ it('should hide the attachment hanging off the note and keep the note target that points at the open person', async () => {const attachmentsResponse = await makeGraphqlAPIRequestWithMemberRole(findAttachmentsOperation,);@@ -287,7 +294,9 @@ describe('inheritedReadabilityObjectRecordsPermissions', () => {collectIds(attachmentsResponse.body.data.attachments.edges),).toEqual([PERSON_ATTACHMENT_ID]);expect(noteTargetsResponse.body.errors).toBeUndefined();- expect(noteTargetsResponse.body.data.noteTargets.edges).toHaveLength(0);+ expect(+ collectIds(noteTargetsResponse.body.data.noteTargets.edges),+ ).toEqual([NOTE_TARGET_ID]);});it('should keep the attachment hidden when ordering through its note', async () => {diff --git a/packages/twenty-server/test/integration/graphql/suites/object-records-permissions/inherited-through-children-readability-object-records-permissions.integration-spec.ts b/packages/twenty-server/test/integration/graphql/suites/object-records-permissions/inherited-through-children-readability-object-records-permissions.integration-spec.tsnew file mode 100644index 00000000000..b301ab8334a--- /dev/null+++ b/packages/twenty-server/test/integration/graphql/suites/object-records-permissions/inherited-through-children-readability-object-records-permissions.integration-spec.ts@@ -0,0 +1,524 @@+import { randomUUID } from 'node:crypto';++import { createOneOperationFactory } from 'test/integration/graphql/utils/create-one-operation-factory.util';+import { deleteManyOperationFactory } from 'test/integration/graphql/utils/delete-many-operation-factory.util';+import { destroyManyOperationFactory } from 'test/integration/graphql/utils/destroy-many-operation-factory.util';+import { findManyOperationFactory } from 'test/integration/graphql/utils/find-many-operation-factory.util';+import { makeGraphqlAPIRequestWithMemberRole } from 'test/integration/graphql/utils/make-graphql-api-request-with-member-role.util';+import { makeGraphqlAPIRequest } from 'test/integration/graphql/utils/make-graphql-api-request.util';+import { restoreManyOperationFactory } from 'test/integration/graphql/utils/restore-many-operation-factory.util';+import { updateOneOperationFactory } from 'test/integration/graphql/utils/update-one-operation-factory.util';+import { setObjectReadability } from 'test/integration/metadata/suites/object-metadata/utils/set-object-readability.util';+import { findOneRoleByLabel } from 'test/integration/metadata/suites/role/utils/find-one-role-by-label.util';+import { updateFeatureFlag } from 'test/integration/metadata/suites/utils/update-feature-flag.util';+import { getAppProviderByClassName } from 'test/integration/utils/get-app-provider-by-class-name.util';+import { getCoreRepository } from 'test/integration/utils/get-core-repository.util';+import {+ FeatureFlagKey,+ MetadataReadability,+ RecordShareAccessLevel,+ RecordSharePrincipalType,+ RecordShareRowCause,+} from 'twenty-shared/types';++import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';+import { type RecordShareService } from 'src/engine/record-share/services/record-share.service';+import { SEED_APPLE_WORKSPACE_ID } from 'src/engine/workspace-manager/dev-seeder/core/constants/seeder-workspaces.constant';+import { WORKSPACE_MEMBER_DATA_SEED_IDS } from 'src/engine/workspace-manager/dev-seeder/data/constants/workspace-member-data-seeds.constant';++const PERSON_ID = randomUUID();+const COMPANY_ID = randomUUID();+const NOTE_ON_PERSON_ID = randomUUID();+const NOTE_ON_COMPANY_ID = randomUUID();+const NOTE_ON_BOTH_ID = randomUUID();+const NOTE_ALONE_ID = randomUUID();+const MEMBER_NOTE_ID = randomUUID();+const PERSON_NOTE_TARGET_ID = randomUUID();+const COMPANY_NOTE_TARGET_ID = randomUUID();+const BOTH_PERSON_NOTE_TARGET_ID = randomUUID();+const BOTH_COMPANY_NOTE_TARGET_ID = randomUUID();+const MEMBER_NOTE_TARGET_ID = randomUUID();+const COMPANY_NOTE_ATTACHMENT_ID = randomUUID();+const PERSON_NOTE_ATTACHMENT_ID = randomUUID();++const NOTE_IDS = [+ NOTE_ON_PERSON_ID,+ NOTE_ON_COMPANY_ID,+ NOTE_ON_BOTH_ID,+ NOTE_ALONE_ID,+ MEMBER_NOTE_ID,+];+const NOTE_TARGET_IDS = [+ PERSON_NOTE_TARGET_ID,+ COMPANY_NOTE_TARGET_ID,+ BOTH_PERSON_NOTE_TARGET_ID,+ BOTH_COMPANY_NOTE_TARGET_ID,+ MEMBER_NOTE_TARGET_ID,+];+const ATTACHMENT_IDS = [COMPANY_NOTE_ATTACHMENT_ID, PERSON_NOTE_ATTACHMENT_ID];++const collectIds = (edges: { node: { id: string } }[]): string[] =>+ edges.map((edge) => edge.node.id).sort();++const findNotesOperation = findManyOperationFactory({+ objectMetadataSingularName: 'note',+ objectMetadataPluralName: 'notes',+ gqlFields: `+ id+ noteTargets {+ edges {+ node {+ id+ }+ }+ }+ `,+ filter: { id: { in: NOTE_IDS } },+});++const findNoteTargetsOperation = findManyOperationFactory({+ objectMetadataSingularName: 'noteTarget',+ objectMetadataPluralName: 'noteTargets',+ gqlFields: 'id',+ filter: { id: { in: NOTE_TARGET_IDS } },+});++const findAttachmentsOperation = findManyOperationFactory({+ objectMetadataSingularName: 'attachment',+ objectMetadataPluralName: 'attachments',+ gqlFields: 'id',+ filter: { id: { in: ATTACHMENT_IDS } },+});++const renameNoteOperation = (noteId: string, title: string) =>+ updateOneOperationFactory({+ objectMetadataSingularName: 'note',+ gqlFields: 'id title',+ recordId: noteId,+ data: { title },+ });++const attachNoteToCompanyOperation = createOneOperationFactory({+ objectMetadataSingularName: 'noteTarget',+ gqlFields: 'id',+ data: {+ id: MEMBER_NOTE_TARGET_ID,+ noteId: NOTE_ON_PERSON_ID,+ targetCompanyId: COMPANY_ID,+ },+});++const detachNoteOnBothFromCompanyOperation = deleteManyOperationFactory({+ objectMetadataSingularName: 'noteTarget',+ objectMetadataPluralName: 'noteTargets',+ gqlFields: 'id',+ filter: { id: { eq: BOTH_COMPANY_NOTE_TARGET_ID } },+});++const reattachNoteOnBothToCompanyOperation = restoreManyOperationFactory({+ objectMetadataSingularName: 'noteTarget',+ objectMetadataPluralName: 'noteTargets',+ gqlFields: 'id',+ filter: { id: { eq: BOTH_COMPANY_NOTE_TARGET_ID } },+});++const setRecordSharingEnabled = (value: boolean) =>+ updateFeatureFlag({+ featureFlag: FeatureFlagKey.IS_RECORD_SHARING_ENABLED,+ value,+ expectToFail: false,+ });++const destroyRecords = ({+ objectMetadataSingularName,+ objectMetadataPluralName,+ ids,+}: {+ objectMetadataSingularName: string;+ objectMetadataPluralName: string;+ ids: string[];+}) =>+ makeGraphqlAPIRequest(+ destroyManyOperationFactory({+ objectMetadataSingularName,+ objectMetadataPluralName,+ gqlFields: 'id',+ filter: { id: { in: ids } },+ }),+ );++describe('inheritedThroughChildrenReadabilityObjectRecordsPermissions', () => {+ let recordShareService: RecordShareService;+ let personObjectMetadataId: string;+ let noteObjectMetadataId: string;++ const sourceId = randomUUID();++ beforeAll(async () => {+ recordShareService =+ getAppProviderByClassName<RecordShareService>('RecordShareService');++ const objectMetadataRepository =+ getCoreRepository<ObjectMetadataEntity>(ObjectMetadataEntity);++ personObjectMetadataId = (+ await objectMetadataRepository.findOneOrFail({+ where: { workspaceId: SEED_APPLE_WORKSPACE_ID, nameSingular: 'person' },+ })+ ).id;+ noteObjectMetadataId = (+ await objectMetadataRepository.findOneOrFail({+ where: { workspaceId: SEED_APPLE_WORKSPACE_ID, nameSingular: 'note' },+ })+ ).id;++ const createRecords = [+ {+ objectMetadataSingularName: 'person',+ data: { id: PERSON_ID, name: { firstName: 'Private' } },+ },+ {+ objectMetadataSingularName: 'company',+ data: { id: COMPANY_ID, name: 'Open company' },+ },+ {+ objectMetadataSingularName: 'note',+ data: { id: NOTE_ON_PERSON_ID, title: 'On the private person' },+ },+ {+ objectMetadataSingularName: 'note',+ data: { id: NOTE_ON_COMPANY_ID, title: 'On the open company' },+ },+ {+ objectMetadataSingularName: 'note',+ data: { id: NOTE_ON_BOTH_ID, title: 'On both' },+ },+ {+ objectMetadataSingularName: 'note',+ data: { id: NOTE_ALONE_ID, title: 'Attached to nothing' },+ },+ {+ objectMetadataSingularName: 'noteTarget',+ data: {+ id: PERSON_NOTE_TARGET_ID,+ noteId: NOTE_ON_PERSON_ID,+ targetPersonId: PERSON_ID,+ },+ },+ {+ objectMetadataSingularName: 'noteTarget',+ data: {+ id: COMPANY_NOTE_TARGET_ID,+ noteId: NOTE_ON_COMPANY_ID,+ targetCompanyId: COMPANY_ID,+ },+ },+ {+ objectMetadataSingularName: 'noteTarget',+ data: {+ id: BOTH_PERSON_NOTE_TARGET_ID,+ noteId: NOTE_ON_BOTH_ID,+ targetPersonId: PERSON_ID,+ },+ },+ {+ objectMetadataSingularName: 'noteTarget',+ data: {+ id: BOTH_COMPANY_NOTE_TARGET_ID,+ noteId: NOTE_ON_BOTH_ID,+ targetCompanyId: COMPANY_ID,+ },+ },+ {+ objectMetadataSingularName: 'attachment',+ data: {+ id: COMPANY_NOTE_ATTACHMENT_ID,+ name: 'company-note-attachment.pdf',+ targetNoteId: NOTE_ON_COMPANY_ID,+ },+ },+ {+ objectMetadataSingularName: 'attachment',+ data: {+ id: PERSON_NOTE_ATTACHMENT_ID,+ name: 'person-note-attachment.pdf',+ targetNoteId: NOTE_ON_PERSON_ID,+ },+ },+ ];++ for (const { objectMetadataSingularName, data } of createRecords) {+ const response = await makeGraphqlAPIRequest(+ createOneOperationFactory({+ objectMetadataSingularName,+ gqlFields: 'id',+ data,+ }),+ );++ expect(response.body.errors).toBeUndefined();+ }++ await setObjectReadability(+ personObjectMetadataId,+ MetadataReadability.PRIVATE,+ );+ await setRecordSharingEnabled(true);+ });++ afterAll(async () => {+ await setRecordSharingEnabled(false);+ await recordShareService.deleteBySourceId({+ workspaceId: SEED_APPLE_WORKSPACE_ID,+ sourceId,+ });+ await recordShareService.deleteByRecordIds({+ workspaceId: SEED_APPLE_WORKSPACE_ID,+ objectMetadataId: noteObjectMetadataId,+ recordIds: NOTE_IDS,+ });+ await setObjectReadability(+ personObjectMetadataId,+ MetadataReadability.OPEN,+ );+ await destroyRecords({+ objectMetadataSingularName: 'attachment',+ objectMetadataPluralName: 'attachments',+ ids: ATTACHMENT_IDS,+ });+ await destroyRecords({+ objectMetadataSingularName: 'noteTarget',+ objectMetadataPluralName: 'noteTargets',+ ids: NOTE_TARGET_IDS,+ });+ await destroyRecords({+ objectMetadataSingularName: 'note',+ objectMetadataPluralName: 'notes',+ ids: NOTE_IDS,+ });+ await destroyRecords({+ objectMetadataSingularName: 'person',+ objectMetadataPluralName: 'people',+ ids: [PERSON_ID],+ });+ await destroyRecords({+ objectMetadataSingularName: 'company',+ objectMetadataPluralName: 'companies',+ ids: [COMPANY_ID],+ });+ });++ describe('without a share row on the person', () => {+ it('should show the notes attached to the open company, their company targets and their attachments only', async () => {+ const notesResponse =+ await makeGraphqlAPIRequestWithMemberRole(findNotesOperation);+ const noteTargetsResponse = await makeGraphqlAPIRequestWithMemberRole(+ findNoteTargetsOperation,+ );+ const attachmentsResponse = await makeGraphqlAPIRequestWithMemberRole(+ findAttachmentsOperation,+ );++ expect(notesResponse.body.errors).toBeUndefined();+ expect(collectIds(notesResponse.body.data.notes.edges)).toEqual(+ [NOTE_ON_COMPANY_ID, NOTE_ON_BOTH_ID].sort(),+ );++ const noteOnBoth = notesResponse.body.data.notes.edges.find(+ (edge: { node: { id: string } }) => edge.node.id === NOTE_ON_BOTH_ID,+ ).node;++ expect(collectIds(noteOnBoth.noteTargets.edges)).toEqual([+ BOTH_COMPANY_NOTE_TARGET_ID,+ ]);+ expect(noteTargetsResponse.body.errors).toBeUndefined();+ expect(+ collectIds(noteTargetsResponse.body.data.noteTargets.edges),+ ).toEqual([COMPANY_NOTE_TARGET_ID, BOTH_COMPANY_NOTE_TARGET_ID].sort());+ expect(attachmentsResponse.body.errors).toBeUndefined();+ expect(+ collectIds(attachmentsResponse.body.data.attachments.edges),+ ).toEqual([COMPANY_NOTE_ATTACHMENT_ID]);+ });++ it('should let the member rename the note on the open company and refuse the one on the private person', async () => {+ const companyNoteResponse = await makeGraphqlAPIRequestWithMemberRole(+ renameNoteOperation(NOTE_ON_COMPANY_ID, 'Renamed on the open company'),+ );+ const personNoteResponse = await makeGraphqlAPIRequestWithMemberRole(+ renameNoteOperation(NOTE_ON_PERSON_ID, 'Renamed on the private person'),+ );++ expect(companyNoteResponse.body.errors).toBeUndefined();+ expect(companyNoteResponse.body.data.updateNote).toEqual({+ id: NOTE_ON_COMPANY_ID,+ title: 'Renamed on the open company',+ });+ expect(personNoteResponse.body.data?.updateNote ?? null).toBeNull();+ expect(personNoteResponse.body.errors).toBeDefined();+ });++ it('should refuse to attach the note on the private person to the open company', async () => {+ const response = await makeGraphqlAPIRequestWithMemberRole(+ attachNoteToCompanyOperation,+ );++ expect(response.body.data?.createNoteTarget ?? null).toBeNull();+ expect(response.body.errors).toBeDefined();+ expect(response.body.errors[0].message).toContain('not writable');+ });++ it('should refuse to restore a detached target of a note the member cannot write', async () => {+ const detachResponse = await makeGraphqlAPIRequest(+ detachNoteOnBothFromCompanyOperation,+ );++ expect(detachResponse.body.errors).toBeUndefined();++ const restoreResponse = await makeGraphqlAPIRequestWithMemberRole(+ reattachNoteOnBothToCompanyOperation,+ );++ expect(restoreResponse.body.data?.restoreNoteTargets ?? null).toBeNull();+ expect(restoreResponse.body.errors).toBeDefined();+ expect(restoreResponse.body.errors[0].message).toContain('not writable');++ await setRecordSharingEnabled(false);++ const reattachResponse = await makeGraphqlAPIRequest(+ reattachNoteOnBothToCompanyOperation,+ );++ expect(reattachResponse.body.errors).toBeUndefined();++ await setRecordSharingEnabled(true);+ });+ });++ describe('with a READ share row on the person', () => {+ beforeAll(async () => {+ await recordShareService.insertMany({+ workspaceId: SEED_APPLE_WORKSPACE_ID,+ recordShares: [+ {+ recordId: PERSON_ID,+ objectMetadataId: personObjectMetadataId,+ principalId: WORKSPACE_MEMBER_DATA_SEED_IDS.JONY,+ principalType: RecordSharePrincipalType.WORKSPACE_MEMBER,+ accessLevel: RecordShareAccessLevel.READ,+ rowCause: RecordShareRowCause.MANUAL,+ sourceId,+ },+ ],+ });+ });++ it('should show every attached note, target and attachment and keep the unattached note hidden', async () => {+ const notesResponse =+ await makeGraphqlAPIRequestWithMemberRole(findNotesOperation);+ const noteTargetsResponse = await makeGraphqlAPIRequestWithMemberRole(+ findNoteTargetsOperation,+ );+ const attachmentsResponse = await makeGraphqlAPIRequestWithMemberRole(+ findAttachmentsOperation,+ );++ expect(notesResponse.body.errors).toBeUndefined();+ expect(collectIds(notesResponse.body.data.notes.edges)).toEqual(+ [NOTE_ON_PERSON_ID, NOTE_ON_COMPANY_ID, NOTE_ON_BOTH_ID].sort(),+ );+ expect(noteTargetsResponse.body.errors).toBeUndefined();+ expect(+ collectIds(noteTargetsResponse.body.data.noteTargets.edges),+ ).toEqual(+ [+ PERSON_NOTE_TARGET_ID,+ COMPANY_NOTE_TARGET_ID,+ BOTH_PERSON_NOTE_TARGET_ID,+ BOTH_COMPANY_NOTE_TARGET_ID,+ ].sort(),+ );+ expect(attachmentsResponse.body.errors).toBeUndefined();+ expect(+ collectIds(attachmentsResponse.body.data.attachments.edges),+ ).toEqual(ATTACHMENT_IDS.sort());+ });++ it('should still refuse to rename the note on the private person or attach it elsewhere', async () => {+ const renameResponse = await makeGraphqlAPIRequestWithMemberRole(+ renameNoteOperation(NOTE_ON_PERSON_ID, 'Renamed with READ'),+ );+ const attachResponse = await makeGraphqlAPIRequestWithMemberRole(+ attachNoteToCompanyOperation,+ );++ expect(renameResponse.body.data?.updateNote ?? null).toBeNull();+ expect(renameResponse.body.errors).toBeDefined();+ expect(attachResponse.body.data?.createNoteTarget ?? null).toBeNull();+ expect(attachResponse.body.errors).toBeDefined();+ });+ });++ describe('with a READ_WRITE share row on the person for the member role', () => {+ beforeAll(async () => {+ const memberRole = await findOneRoleByLabel({ label: 'Member' });++ await recordShareService.insertMany({+ workspaceId: SEED_APPLE_WORKSPACE_ID,+ recordShares: [+ {+ recordId: PERSON_ID,+ objectMetadataId: personObjectMetadataId,+ principalId: memberRole.id,+ principalType: RecordSharePrincipalType.ROLE,+ accessLevel: RecordShareAccessLevel.READ_WRITE,+ rowCause: RecordShareRowCause.MANUAL,+ sourceId,+ },+ ],+ });+ });++ it('should let the member rename the note on the private person and attach it to the open company', async () => {+ const renameResponse = await makeGraphqlAPIRequestWithMemberRole(+ renameNoteOperation(NOTE_ON_PERSON_ID, 'Renamed with READ_WRITE'),+ );+ const attachResponse = await makeGraphqlAPIRequestWithMemberRole(+ attachNoteToCompanyOperation,+ );++ expect(renameResponse.body.errors).toBeUndefined();+ expect(renameResponse.body.data.updateNote).toEqual({+ id: NOTE_ON_PERSON_ID,+ title: 'Renamed with READ_WRITE',+ });+ expect(attachResponse.body.errors).toBeUndefined();+ expect(attachResponse.body.data.createNoteTarget.id).toBe(+ MEMBER_NOTE_TARGET_ID,+ );+ });++ it('should let the member read back a note they created before attaching it anywhere', async () => {+ const createResponse = await makeGraphqlAPIRequestWithMemberRole(+ createOneOperationFactory({+ objectMetadataSingularName: 'note',+ gqlFields: 'id',+ data: { id: MEMBER_NOTE_ID, title: 'Created by the member' },+ }),+ );+ const notesResponse =+ await makeGraphqlAPIRequestWithMemberRole(findNotesOperation);++ expect(createResponse.body.errors).toBeUndefined();+ expect(notesResponse.body.errors).toBeUndefined();+ expect(collectIds(notesResponse.body.data.notes.edges)).toEqual(+ [+ NOTE_ON_PERSON_ID,+ NOTE_ON_COMPANY_ID,+ NOTE_ON_BOTH_ID,+ MEMBER_NOTE_ID,+ ].sort(),+ );+ });+ });+});diff --git a/packages/twenty-server/test/integration/upgrade/suites/2-41-workspace-command-1789373200002-make-notes-and-tasks-inherit-their-targets.integration-spec.ts b/packages/twenty-server/test/integration/upgrade/suites/2-41-workspace-command-1789373200002-make-notes-and-tasks-inherit-their-targets.integration-spec.tsnew file mode 100644index 00000000000..2738b1acccf--- /dev/null+++ b/packages/twenty-server/test/integration/upgrade/suites/2-41-workspace-command-1789373200002-make-notes-and-tasks-inherit-their-targets.integration-spec.ts@@ -0,0 +1,199 @@+import { updateOneObjectMetadata } from 'test/integration/metadata/suites/object-metadata/utils/update-one-object-metadata.util';+import { getAppProviderByClassName } from 'test/integration/utils/get-app-provider-by-class-name.util';+import { getCoreRepository } from 'test/integration/utils/get-core-repository.util';+import { STANDARD_OBJECT_FIELDS } from 'twenty-shared/metadata';+import { MetadataReadability } from 'twenty-shared/types';+import { In } from 'typeorm';++import { type MakeNotesAndTasksInheritTheirTargetsCommand } from 'src/database/commands/upgrade-version-command/2-41/2-41-workspace-command-1789373200002-make-notes-and-tasks-inherit-their-targets.command';+import { ObjectMetadataEntity } from 'src/engine/metadata-modules/object-metadata/object-metadata.entity';+import { buildSystemAuthContext } from 'src/engine/twenty-orm/utils/build-system-auth-context.util';+import { WorkspaceOrmManager } from 'src/engine/twenty-orm/workspace-orm.manager';+import { SEED_APPLE_WORKSPACE_ID } from 'src/engine/workspace-manager/dev-seeder/core/constants/seeder-workspaces.constant';++const authContext = buildSystemAuthContext(SEED_APPLE_WORKSPACE_ID);++// Listed here rather than imported from the command: a value import would load+// the command's module graph, which jest cannot resolve in this suite+const STANDARD_OBJECTS_TO_INHERIT_THROUGH_TARGETS = [+ {+ nameSingular: 'note',+ readabilityParentFieldUniversalIdentifiers: [+ STANDARD_OBJECT_FIELDS.note.noteTargets.universalIdentifier,+ ],+ },+ {+ nameSingular: 'noteTarget',+ readabilityParentFieldUniversalIdentifiers: [+ STANDARD_OBJECT_FIELDS.noteTarget.targetPerson.universalIdentifier,+ ],+ },+ {+ nameSingular: 'task',+ readabilityParentFieldUniversalIdentifiers: [+ STANDARD_OBJECT_FIELDS.task.taskTargets.universalIdentifier,+ ],+ },+ {+ nameSingular: 'taskTarget',+ readabilityParentFieldUniversalIdentifiers: [+ STANDARD_OBJECT_FIELDS.taskTarget.targetPerson.universalIdentifier,+ ],+ },+];++const OBJECT_NAMES_SINGULAR = STANDARD_OBJECTS_TO_INHERIT_THROUGH_TARGETS.map(+ ({ nameSingular }) => nameSingular,+);++const RUN_ON_WORKSPACE_ARGS = {+ workspaceId: SEED_APPLE_WORKSPACE_ID,+ options: {},+ index: 0,+ total: 1,+};++type ReadabilityState = {+ readability: MetadataReadability;+ readabilityParentFieldUniversalIdentifiers: string[] | null;+};++const EXPECTED_TARGET_STATE: Record<string, ReadabilityState> =+ Object.fromEntries(+ STANDARD_OBJECTS_TO_INHERIT_THROUGH_TARGETS.map(+ ({ nameSingular, readabilityParentFieldUniversalIdentifiers }) => [+ nameSingular,+ {+ readability: MetadataReadability.INHERITED,+ readabilityParentFieldUniversalIdentifiers: [+ ...readabilityParentFieldUniversalIdentifiers,+ ],+ },+ ],+ ),+ );++// The state the previous 2-41 command leaves: targets inherit from their note+// or task, notes and tasks are still OPEN+const LEGACY_STATE: Record<string, ReadabilityState> = {+ note: {+ readability: MetadataReadability.OPEN,+ readabilityParentFieldUniversalIdentifiers: null,+ },+ noteTarget: {+ readability: MetadataReadability.INHERITED,+ readabilityParentFieldUniversalIdentifiers: [+ STANDARD_OBJECT_FIELDS.noteTarget.note.universalIdentifier,+ ],+ },+ task: {+ readability: MetadataReadability.OPEN,+ readabilityParentFieldUniversalIdentifiers: null,+ },+ taskTarget: {+ readability: MetadataReadability.INHERITED,+ readabilityParentFieldUniversalIdentifiers: [+ STANDARD_OBJECT_FIELDS.taskTarget.task.universalIdentifier,+ ],+ },+};++describe('2-41 workspace command 1789373200002 - MakeNotesAndTasksInheritTheirTargetsCommand (integration)', () => {+ let command: MakeNotesAndTasksInheritTheirTargetsCommand;+ let workspaceOrmManager: WorkspaceOrmManager;+ let objectMetadataIdByNameSingular: Record<string, string>;++ const objectMetadataRepository = () =>+ getCoreRepository<ObjectMetadataEntity>(ObjectMetadataEntity);++ const runCommand = (options: { dryRun?: boolean } = {}) =>+ workspaceOrmManager.executeInWorkspaceContext(+ () => command.runOnWorkspace({ ...RUN_ON_WORKSPACE_ARGS, options }),+ authContext,+ );++ const findReadabilityStates = async (): Promise<+ Record<string, ReadabilityState>+ > => {+ const objectMetadataItems = await objectMetadataRepository().find({+ where: {+ workspaceId: SEED_APPLE_WORKSPACE_ID,+ nameSingular: In(OBJECT_NAMES_SINGULAR),+ },+ });++ return Object.fromEntries(+ objectMetadataItems.map((objectMetadata) => [+ objectMetadata.nameSingular,+ {+ readability: objectMetadata.readability,+ readabilityParentFieldUniversalIdentifiers:+ objectMetadata.readabilityParentFieldUniversalIdentifiers,+ },+ ]),+ );+ };++ const setLegacyState = async () => {+ for (const [nameSingular, state] of Object.entries(LEGACY_STATE)) {+ const objectMetadataId = objectMetadataIdByNameSingular[nameSingular];++ await objectMetadataRepository().update(objectMetadataId, state);++ const { errors } = await updateOneObjectMetadata({+ expectToFail: false,+ input: {+ idToUpdate: objectMetadataId,+ updatePayload: { description: 'readability reset to legacy state' },+ },+ });++ expect(errors).toBeUndefined();+ }+ };++ beforeAll(async () => {+ command =+ getAppProviderByClassName<MakeNotesAndTasksInheritTheirTargetsCommand>(+ 'MakeNotesAndTasksInheritTheirTargetsCommand',+ );+ workspaceOrmManager = getAppProviderByClassName<WorkspaceOrmManager>(+ 'WorkspaceOrmManager',+ );++ const objectMetadataItems = await objectMetadataRepository().find({+ where: {+ workspaceId: SEED_APPLE_WORKSPACE_ID,+ nameSingular: In(OBJECT_NAMES_SINGULAR),+ },+ });++ expect(objectMetadataItems).toHaveLength(OBJECT_NAMES_SINGULAR.length);++ objectMetadataIdByNameSingular = Object.fromEntries(+ objectMetadataItems.map((objectMetadata) => [+ objectMetadata.nameSingular,+ objectMetadata.id,+ ]),+ );++ await setLegacyState();+ });++ afterAll(async () => {+ await runCommand();+ });++ it('leaves the legacy state on a dry run', async () => {+ await runCommand({ dryRun: true });++ expect(await findReadabilityStates()).toEqual(LEGACY_STATE);+ });++ it('makes notes and tasks inherit through their targets and skips them on a second run', async () => {+ await runCommand();+ await runCommand();++ expect(await findReadabilityStates()).toEqual(EXPECTED_TARGET_STATE);+ });+});