@sphereon/ssi-sdk.data-store 0.15.2-next.6 → 0.15.2-next.95

package/src/entities/contact/BaseConfigEntity.ts

@@ -1,8 +1,16 @@
-import { BaseEntity, Entity, PrimaryGeneratedColumn, TableInheritance } from 'typeorm'
+import { BaseEntity, Entity, JoinColumn, OneToOne, PrimaryGeneratedColumn, TableInheritance } from 'typeorm'
+import { ConnectionEntity } from './ConnectionEntity'
 
-@Entity('BaseConfigEntity') // FIXME rename it to 'BaseConfig'
+@Entity('BaseConfig')
 @TableInheritance({ column: { type: 'varchar', name: 'type' } })
 export abstract class BaseConfigEntity extends BaseEntity {
   @PrimaryGeneratedColumn('uuid')
   id!: string
+
+  @OneToOne(() => ConnectionEntity, (connection: ConnectionEntity) => connection.config, {
+    cascade: ['insert', 'update'],
+    onDelete: 'CASCADE',
+  })
+  @JoinColumn({ name: 'connection_id' })
+  connection?: ConnectionEntity
 }

package/src/entities/contact/BaseContactEntity.ts

@@ -0,0 +1,30 @@
+import { BaseEntity,
+  BeforeInsert,
+  BeforeUpdate, CreateDateColumn, Entity, JoinColumn, OneToOne, PrimaryGeneratedColumn, TableInheritance, UpdateDateColumn } from 'typeorm'
+import { PartyEntity } from './PartyEntity'
+
+@Entity('BaseContact')
+@TableInheritance({ column: { type: 'varchar', name: 'type' } })
+export abstract class BaseContactEntity extends BaseEntity {
+  @PrimaryGeneratedColumn('uuid')
+  id!: string
+
+  @CreateDateColumn({ name: 'created_at', nullable: false })
+  createdAt!: Date
+
+  @UpdateDateColumn({ name: 'last_updated_at', nullable: false })
+  lastUpdatedAt!: Date
+
+  @OneToOne(() => PartyEntity, (party: PartyEntity) => party.contact, {
+    onDelete: 'CASCADE',
+  })
+  @JoinColumn({ name: 'party_id' })
+  party!: PartyEntity
+
+  // By default, @UpdateDateColumn in TypeORM updates the timestamp only when the entity's top-level properties change.
+  @BeforeInsert()
+  @BeforeUpdate()
+  updateUpdatedDate(): void {
+    this.lastUpdatedAt = new Date()
+  }
+}

package/src/entities/contact/ConnectionEntity.ts

@@ -1,9 +1,9 @@
 import { Entity, Column, PrimaryGeneratedColumn, OneToOne, JoinColumn, BaseEntity } from 'typeorm'
 import { BaseConfigEntity } from './BaseConfigEntity'
-import { BasicConnectionConfig, ConnectionTypeEnum, IBasicConnection, IDidAuthConfig, IOpenIdConfig } from '../../types'
+import { ConnectionTypeEnum } from '../../types'
 import { IdentityEntity } from './IdentityEntity'
-import { OpenIdConfigEntity, openIdConfigEntityFrom } from './OpenIdConfigEntity'
-import { DidAuthConfigEntity, didAuthConfigEntityFrom } from './DidAuthConfigEntity'
+import { OpenIdConfigEntity } from './OpenIdConfigEntity'
+import { DidAuthConfigEntity } from './DidAuthConfigEntity'
 
 @Entity('Connection')
 export class ConnectionEntity extends BaseEntity {
@@ -24,25 +24,6 @@ export class ConnectionEntity extends BaseEntity {
   @OneToOne(() => IdentityEntity, (identity: IdentityEntity) => identity.connection, {
     onDelete: 'CASCADE',
   })
-  @JoinColumn({ name: 'identityId' })
+  @JoinColumn({ name: 'identity_id' })
   identity!: IdentityEntity
 }
-
-export const connectionEntityFrom = (connection: IBasicConnection): ConnectionEntity => {
-  const connectionEntity = new ConnectionEntity()
-  connectionEntity.type = connection.type
-  connectionEntity.config = configEntityFrom(connection.type, connection.config)
-
-  return connectionEntity
-}
-
-const configEntityFrom = (type: ConnectionTypeEnum, config: BasicConnectionConfig): BaseConfigEntity => {
-  switch (type) {
-    case ConnectionTypeEnum.OPENID_CONNECT:
-      return openIdConfigEntityFrom(config as IOpenIdConfig)
-    case ConnectionTypeEnum.SIOPv2:
-      return didAuthConfigEntityFrom(config as IDidAuthConfig)
-    default:
-      throw new Error('Connection type not supported')
-  }
-}

package/src/entities/contact/CorrelationIdentifierEntity.ts

@@ -1,7 +1,8 @@
 import { Entity, Column, PrimaryGeneratedColumn, BaseEntity, OneToOne, JoinColumn, BeforeInsert, BeforeUpdate } from 'typeorm'
-import { CorrelationIdentifierEnum, BasicCorrelationIdentifier } from '../../types'
+import { CorrelationIdentifierEnum, ValidationConstraint } from '../../types'
 import { IdentityEntity } from './IdentityEntity'
 import { IsNotEmpty, validate, ValidationError } from 'class-validator'
+import { getConstraint } from '../../utils/ValidatorUtils'
 
 @Entity('CorrelationIdentifier')
 export class CorrelationIdentifierEntity extends BaseEntity {
@@ -18,24 +19,19 @@ export class CorrelationIdentifierEntity extends BaseEntity {
   @OneToOne(() => IdentityEntity, (identity: IdentityEntity) => identity.identifier, {
     onDelete: 'CASCADE',
   })
-  @JoinColumn({ name: 'identityId' })
+  @JoinColumn({ name: 'identity_id' })
   identity!: IdentityEntity
 
   @BeforeInsert()
   @BeforeUpdate()
-  async validate() {
+  async validate(): Promise<void> {
     const validation: Array<ValidationError> = await validate(this)
     if (validation.length > 0) {
-      return Promise.reject(Error(Object.values(validation[0].constraints!)[0]))
+      const constraint: ValidationConstraint | undefined = getConstraint(validation[0])
+      if (constraint) {
+        const message: string = Object.values(constraint!)[0]
+        return Promise.reject(Error(message))
+      }
     }
-    return
   }
 }
-
-export const correlationIdentifierEntityFrom = (identifier: BasicCorrelationIdentifier): CorrelationIdentifierEntity => {
-  const identifierEntity = new CorrelationIdentifierEntity()
-  identifierEntity.type = identifier.type
-  identifierEntity.correlationId = identifier.correlationId
-
-  return identifierEntity
-}

package/src/entities/contact/DidAuthConfigEntity.ts

@@ -1,7 +1,5 @@
-import { ChildEntity, Column, JoinColumn, OneToOne } from 'typeorm'
+import { ChildEntity, Column } from 'typeorm'
 import { BaseConfigEntity } from './BaseConfigEntity'
-import { BasicDidAuthConfig } from '../../types'
-import { ConnectionEntity } from './ConnectionEntity'
 
 @ChildEntity('DidAuthConfig')
 export class DidAuthConfigEntity extends BaseConfigEntity {
@@ -13,19 +11,4 @@ export class DidAuthConfigEntity extends BaseConfigEntity {
 
   @Column({ name: 'session_id', length: 255, nullable: false })
   sessionId!: string
-
-  @OneToOne(() => ConnectionEntity, (connection: ConnectionEntity) => connection.config, {
-    onDelete: 'CASCADE',
-  })
-  @JoinColumn({ name: 'connectionId' })
-  connection?: ConnectionEntity
-}
-
-export const didAuthConfigEntityFrom = (config: BasicDidAuthConfig): DidAuthConfigEntity => {
-  const didAuthConfig = new DidAuthConfigEntity()
-  didAuthConfig.identifier = config.identifier.did
-  didAuthConfig.redirectUrl = config.redirectUrl
-  didAuthConfig.sessionId = config.sessionId
-
-  return didAuthConfig
 }

package/src/entities/contact/ElectronicAddressEntity.ts

@@ -0,0 +1,60 @@
+import { IsNotEmpty, validate, ValidationError } from 'class-validator'
+import {
+  Entity,
+  Column,
+  PrimaryGeneratedColumn,
+  BaseEntity,
+  ManyToOne,
+  BeforeInsert,
+  BeforeUpdate,
+  CreateDateColumn,
+  UpdateDateColumn,
+} from 'typeorm'
+import { PartyEntity } from './PartyEntity'
+import { getConstraint } from '../../utils/ValidatorUtils'
+import { ElectronicAddressType, ValidationConstraint } from '../../types'
+
+@Entity('ElectronicAddress')
+export class ElectronicAddressEntity extends BaseEntity {
+  @PrimaryGeneratedColumn('uuid')
+  id!: string
+
+  @Column({ name: 'type', length: 255, nullable: false })
+  @IsNotEmpty({ message: 'Blank electronic address types are not allowed' })
+  type!: ElectronicAddressType
+
+  @Column({ name: 'electronic_address', length: 255, nullable: false })
+  @IsNotEmpty({ message: 'Blank electronic addresses are not allowed' })
+  electronicAddress!: string
+
+  @ManyToOne(() => PartyEntity, (party: PartyEntity) => party.electronicAddresses, {
+    onDelete: 'CASCADE',
+  })
+  party!: PartyEntity
+
+  @CreateDateColumn({ name: 'created_at', nullable: false })
+  createdAt!: Date
+
+  @UpdateDateColumn({ name: 'last_updated_at', nullable: false })
+  lastUpdatedAt!: Date
+
+  // By default, @UpdateDateColumn in TypeORM updates the timestamp only when the entity's top-level properties change.
+  @BeforeInsert()
+  @BeforeUpdate()
+  updateUpdatedDate(): void {
+    this.lastUpdatedAt = new Date()
+  }
+
+  @BeforeInsert()
+  @BeforeUpdate()
+  async validate(): Promise<void> {
+    const validation: Array<ValidationError> = await validate(this)
+    if (validation.length > 0) {
+      const constraint: ValidationConstraint | undefined = getConstraint(validation[0])
+      if (constraint) {
+        const message: string = Object.values(constraint!)[0]
+        return Promise.reject(Error(message))
+      }
+    }
+  }
+}

package/src/entities/contact/IdentityEntity.ts

@@ -13,11 +13,12 @@ import {
   BeforeUpdate,
 } from 'typeorm'
 import { IsNotEmpty, validate, ValidationError } from 'class-validator'
-import { correlationIdentifierEntityFrom, CorrelationIdentifierEntity } from './CorrelationIdentifierEntity'
-import { ConnectionEntity, connectionEntityFrom } from './ConnectionEntity'
-import { IdentityMetadataItemEntity, metadataItemEntityFrom } from './IdentityMetadataItemEntity'
-import { BasicMetadataItem, IBasicIdentity, IdentityRoleEnum } from '../../types'
-import { ContactEntity } from './ContactEntity'
+import { CorrelationIdentifierEntity } from './CorrelationIdentifierEntity'
+import { ConnectionEntity } from './ConnectionEntity'
+import { IdentityMetadataItemEntity } from './IdentityMetadataItemEntity'
+import { IdentityRoleEnum, ValidationConstraint } from '../../types'
+import { PartyEntity } from './PartyEntity'
+import { getConstraint } from '../../utils/ValidatorUtils'
 
 @Entity('Identity')
 export class IdentityEntity extends BaseEntity {
@@ -57,7 +58,7 @@ export class IdentityEntity extends BaseEntity {
     eager: true,
     nullable: false,
   })
-  @JoinColumn({ name: 'metadataId' })
+  @JoinColumn({ name: 'metadata_id' }) // TODO check in db file
   metadata!: Array<IdentityMetadataItemEntity>
 
   @CreateDateColumn({ name: 'created_at', nullable: false })
@@ -66,39 +67,31 @@ export class IdentityEntity extends BaseEntity {
   @UpdateDateColumn({ name: 'last_updated_at', nullable: false })
   lastUpdatedAt!: Date
 
-  @ManyToOne(() => ContactEntity, (contact: ContactEntity) => contact.identities, {
+  @ManyToOne(() => PartyEntity, (party: PartyEntity) => party.identities, {
     onDelete: 'CASCADE',
   })
-  contact!: ContactEntity
+  party!: PartyEntity
 
-  @Column({ name: 'contactId', nullable: true })
-  contactId!: string
+  @Column({ name: 'partyId', nullable: true })
+  partyId!: string
 
   // By default, @UpdateDateColumn in TypeORM updates the timestamp only when the entity's top-level properties change.
   @BeforeInsert()
   @BeforeUpdate()
-  updateUpdatedDate() {
+  updateUpdatedDate(): void {
     this.lastUpdatedAt = new Date()
   }
 
   @BeforeInsert()
   @BeforeUpdate()
-  async validate() {
+  async validate(): Promise<void> {
     const validation: Array<ValidationError> = await validate(this)
     if (validation.length > 0) {
-      return Promise.reject(Error(Object.values(validation[0].constraints!)[0]))
+      const constraint: ValidationConstraint | undefined = getConstraint(validation[0])
+      if (constraint) {
+        const message: string = Object.values(constraint!)[0]
+        return Promise.reject(Error(message))
+      }
     }
-    return
   }
 }
-
-export const identityEntityFrom = (args: IBasicIdentity): IdentityEntity => {
-  const identityEntity = new IdentityEntity()
-  identityEntity.alias = args.alias
-  identityEntity.roles = args.roles
-  identityEntity.identifier = correlationIdentifierEntityFrom(args.identifier)
-  identityEntity.connection = args.connection ? connectionEntityFrom(args.connection) : undefined
-  identityEntity.metadata = args.metadata ? args.metadata.map((item: BasicMetadataItem) => metadataItemEntityFrom(item)) : []
-
-  return identityEntity
-}

package/src/entities/contact/IdentityMetadataItemEntity.ts

@@ -1,7 +1,8 @@
 import { Entity, Column, PrimaryGeneratedColumn, BaseEntity, ManyToOne, BeforeInsert, BeforeUpdate } from 'typeorm'
-import { BasicMetadataItem } from '../../types'
+import { ValidationConstraint } from '../../types'
 import { IdentityEntity } from './IdentityEntity'
 import { IsNotEmpty, validate, ValidationError } from 'class-validator'
+import { getConstraint } from '../../utils/ValidatorUtils'
 
 @Entity('IdentityMetadata')
 export class IdentityMetadataItemEntity extends BaseEntity {
@@ -21,19 +22,14 @@ export class IdentityMetadataItemEntity extends BaseEntity {
 
   @BeforeInsert()
   @BeforeUpdate()
-  async validate() {
+  async validate(): Promise<void> {
     const validation: Array<ValidationError> = await validate(this)
     if (validation.length > 0) {
-      return Promise.reject(Error(Object.values(validation[0].constraints!)[0]))
+      const constraint: ValidationConstraint | undefined = getConstraint(validation[0])
+      if (constraint) {
+        const message: string = Object.values(constraint!)[0]
+        return Promise.reject(Error(message))
+      }
     }
-    return
   }
 }
-
-export const metadataItemEntityFrom = (item: BasicMetadataItem): IdentityMetadataItemEntity => {
-  const metadataItem = new IdentityMetadataItemEntity()
-  metadataItem.label = item.label
-  metadataItem.value = item.value
-
-  return metadataItem
-}

package/src/entities/contact/NaturalPersonEntity.ts

@@ -0,0 +1,38 @@
+import { Column, ChildEntity, BeforeInsert, BeforeUpdate } from 'typeorm'
+import { BaseContactEntity } from './BaseContactEntity'
+import { ValidationConstraint } from '../../types'
+import { validate, IsNotEmpty, ValidationError, Validate } from 'class-validator'
+import { IsNonEmptyStringConstraint } from '../validators'
+import { getConstraint } from '../../utils/ValidatorUtils'
+
+@ChildEntity('NaturalPerson')
+export class NaturalPersonEntity extends BaseContactEntity {
+  @Column({ name: 'first_name', length: 255, nullable: false, unique: false })
+  @IsNotEmpty({ message: 'Blank first names are not allowed' })
+  firstName!: string
+
+  @Column({ name: 'middle_name', length: 255, nullable: true, unique: false })
+  @Validate(IsNonEmptyStringConstraint, { message: 'Blank middle names are not allowed' })
+  middleName?: string
+
+  @Column({ name: 'last_name', length: 255, nullable: false, unique: false })
+  @IsNotEmpty({ message: 'Blank last names are not allowed' })
+  lastName!: string
+
+  @Column({ name: 'display_name', length: 255, nullable: false, unique: false })
+  @IsNotEmpty({ message: 'Blank display names are not allowed' })
+  displayName!: string
+
+  @BeforeInsert()
+  @BeforeUpdate()
+  async validate(): Promise<void> {
+    const validation: Array<ValidationError> = await validate(this)
+    if (validation.length > 0) {
+      const constraint: ValidationConstraint | undefined = getConstraint(validation[0])
+      if (constraint) {
+        const message: string = Object.values(constraint!)[0]
+        return Promise.reject(Error(message))
+      }
+    }
+  }
+}

package/src/entities/contact/OpenIdConfigEntity.ts

@@ -1,7 +1,5 @@
-import { ChildEntity, Column, JoinColumn, OneToOne } from 'typeorm'
+import { ChildEntity, Column } from 'typeorm'
 import { BaseConfigEntity } from './BaseConfigEntity'
-import { BasicOpenIdConfig } from '../../types'
-import { ConnectionEntity } from './ConnectionEntity'
 
 @ChildEntity('OpenIdConfig')
 export class OpenIdConfigEntity extends BaseConfigEntity {
@@ -25,24 +23,4 @@ export class OpenIdConfigEntity extends BaseConfigEntity {
 
   @Column('text', { name: 'client_auth_method', nullable: false })
   clientAuthMethod!: 'basic' | 'post' | undefined
-
-  @OneToOne(() => ConnectionEntity, (connection: ConnectionEntity) => connection.config, {
-    cascade: ['insert', 'update'],
-    onDelete: 'CASCADE',
-  })
-  @JoinColumn({ name: 'connectionId' })
-  connection?: ConnectionEntity
-}
-
-export const openIdConfigEntityFrom = (config: BasicOpenIdConfig): OpenIdConfigEntity => {
-  const openIdConfig = new OpenIdConfigEntity()
-  openIdConfig.clientId = config.clientId
-  openIdConfig.clientSecret = config.clientSecret
-  openIdConfig.scopes = config.scopes
-  openIdConfig.issuer = config.issuer
-  openIdConfig.redirectUrl = config.redirectUrl
-  openIdConfig.dangerouslyAllowInsecureHttpRequests = config.dangerouslyAllowInsecureHttpRequests
-  openIdConfig.clientAuthMethod = config.clientAuthMethod
-
-  return openIdConfig
 }

package/src/entities/contact/OrganizationEntity.ts

@@ -0,0 +1,34 @@
+import { JoinColumn, OneToOne, Column, ChildEntity, BeforeInsert, BeforeUpdate } from 'typeorm'
+import { PartyEntity } from './PartyEntity'
+import { BaseContactEntity } from './BaseContactEntity'
+import { ValidationConstraint } from '../../types'
+import { validate, IsNotEmpty, ValidationError } from 'class-validator'
+import { getConstraint } from '../../utils/ValidatorUtils'
+
+@ChildEntity('Organization')
+export class OrganizationEntity extends BaseContactEntity {
+  @Column({ name: 'legal_name', length: 255, nullable: false, unique: true })
+  @IsNotEmpty({ message: 'Blank legal names are not allowed' })
+  legalName!: string
+
+  @Column({ name: 'display_name', length: 255, nullable: false, unique: false })
+  @IsNotEmpty({ message: 'Blank display names are not allowed' })
+  displayName!: string
+
+  @OneToOne(() => PartyEntity)
+  @JoinColumn({ name: 'party_id' })
+  party!: PartyEntity
+
+  @BeforeInsert()
+  @BeforeUpdate()
+  async validate(): Promise<void> {
+    const validation: Array<ValidationError> = await validate(this)
+    if (validation.length > 0) {
+      const constraint: ValidationConstraint | undefined = getConstraint(validation[0])
+      if (constraint) {
+        const message: string = Object.values(constraint!)[0]
+        return Promise.reject(Error(message))
+      }
+    }
+  }
+}

package/src/entities/contact/PartyEntity.ts

@@ -0,0 +1,118 @@
+import {
+  BaseEntity,
+  BeforeInsert,
+  BeforeUpdate,
+  Column,
+  CreateDateColumn,
+  Entity,
+  JoinColumn,
+  ManyToOne,
+  OneToMany,
+  OneToOne,
+  PrimaryGeneratedColumn,
+  UpdateDateColumn,
+} from 'typeorm'
+import { ValidationConstraint } from '../../types'
+import { IdentityEntity } from './IdentityEntity'
+import { validate, ValidationError } from 'class-validator'
+import { PartyTypeEntity } from './PartyTypeEntity'
+import { BaseContactEntity } from './BaseContactEntity'
+import { PartyRelationshipEntity } from './PartyRelationshipEntity'
+import { getConstraint } from '../../utils/ValidatorUtils'
+import { ElectronicAddressEntity } from './ElectronicAddressEntity'
+
+@Entity('Party')
+export class PartyEntity extends BaseEntity {
+  @PrimaryGeneratedColumn('uuid')
+  id!: string
+
+  @Column({ name: 'uri', length: 255 })
+  uri?: string
+
+  @OneToMany(() => IdentityEntity, (identity: IdentityEntity) => identity.party, {
+    cascade: true,
+    onDelete: 'CASCADE',
+    eager: true,
+    nullable: false,
+  })
+  @JoinColumn({ name: 'identity_id' })
+  identities!: Array<IdentityEntity>
+
+  @OneToMany(() => ElectronicAddressEntity, (electronicAddress: ElectronicAddressEntity) => electronicAddress.party, {
+    cascade: true,
+    onDelete: 'CASCADE',
+    eager: true,
+    nullable: false,
+  })
+  @JoinColumn({ name: 'electronic_address_id' })
+  electronicAddresses!: Array<ElectronicAddressEntity>
+
+  @ManyToOne(() => PartyTypeEntity, (contactType: PartyTypeEntity) => contactType.parties, {
+    cascade: true,
+    nullable: false,
+    eager: true,
+  })
+  @JoinColumn({ name: 'party_type_id' })
+  partyType!: PartyTypeEntity
+
+  @OneToOne(() => BaseContactEntity, (contact: BaseContactEntity) => contact.party, {
+    cascade: true,
+    onDelete: 'CASCADE',
+    eager: true,
+    nullable: false,
+  })
+  contact!: BaseContactEntity
+
+  @OneToMany(() => PartyRelationshipEntity, (relationship: PartyRelationshipEntity) => relationship.left, {
+    cascade: true,
+    onDelete: 'CASCADE',
+    eager: true,
+    nullable: false,
+  })
+  @JoinColumn({ name: 'relationship_id' })
+  relationships!: Array<PartyRelationshipEntity>
+
+  @CreateDateColumn({ name: 'created_at', nullable: false })
+  createdAt!: Date
+
+  @UpdateDateColumn({ name: 'last_updated_at', nullable: false })
+  lastUpdatedAt!: Date
+
+  // By default, @UpdateDateColumn in TypeORM updates the timestamp only when the entity's top-level properties change.
+  @BeforeInsert()
+  @BeforeUpdate()
+  updateUpdatedDate(): void {
+    this.lastUpdatedAt = new Date()
+  }
+
+  @BeforeInsert()
+  @BeforeUpdate()
+  async checkUniqueTenantId(): Promise<undefined> {
+    const result: Array<PartyEntity> = await PartyEntity.find({
+      where: {
+        partyType: {
+          tenantId: this.partyType.tenantId,
+        },
+      },
+    })
+
+    if (result?.length > 0) {
+      return Promise.reject(Error('Tenant id already in use'))
+    }
+
+    return
+  }
+
+  @BeforeInsert()
+  @BeforeUpdate()
+  async validate(): Promise<void> {
+    const validation: Array<ValidationError> = await validate(this)
+    if (validation.length > 0) {
+      const constraint: ValidationConstraint | undefined = getConstraint(validation[0])
+      if (constraint) {
+        const message: string = Object.values(constraint!)[0]
+        return Promise.reject(Error(message))
+      }
+    }
+  }
+}

package/src/entities/contact/PartyRelationshipEntity.ts

@@ -0,0 +1,61 @@
+import {
+  Entity,
+  PrimaryGeneratedColumn,
+  CreateDateColumn,
+  UpdateDateColumn,
+  ManyToOne,
+  Column,
+  Index,
+  BeforeInsert,
+  BeforeUpdate,
+  JoinColumn,
+} from 'typeorm'
+import { PartyEntity } from './PartyEntity'
+
+@Entity('PartyRelationship')
+@Index('IDX_PartyRelationship_left_right', ['left', 'right'], { unique: true })
+export class PartyRelationshipEntity {
+  @PrimaryGeneratedColumn('uuid')
+  id!: string
+
+  @ManyToOne(() => PartyEntity, {
+    nullable: false,
+    onDelete: 'CASCADE',
+  })
+  @JoinColumn({ name: 'left_id' })
+  left!: PartyEntity
+
+  @Column({ name: 'left_id', nullable: false })
+  leftId!: string
+
+  @ManyToOne(() => PartyEntity, {
+    nullable: false,
+    onDelete: 'CASCADE',
+  })
+  @JoinColumn({ name: 'right_id' })
+  right!: PartyEntity
+
+  @Column({ name: 'right_id', nullable: false })
+  rightId!: string
+
+  @CreateDateColumn({ name: 'created_at', nullable: false })
+  createdAt!: Date
+
+  @UpdateDateColumn({ name: 'last_updated_at', nullable: false })
+  lastUpdatedAt!: Date
+
+  // By default, @UpdateDateColumn in TypeORM updates the timestamp only when the entity's top-level properties change.
+  @BeforeInsert()
+  @BeforeUpdate()
+  updateUpdatedDate(): void {
+    this.lastUpdatedAt = new Date()
+  }
+
+  @BeforeInsert()
+  @BeforeUpdate()
+  async checkRelationshipSides(): Promise<void> {
+    if ((this.left?.id ?? this.leftId) === (this.right?.id ?? this.rightId)) {
+      return Promise.reject(Error('Cannot use the same id for both sides of the relationship'))
+    }
+  }
+}