@sphereon/ssi-sdk.data-store 0.24.0 → 0.24.1-next.112

package/src/__tests__/pd-manager.store.test.ts

@@ -0,0 +1,191 @@
+import { DataSource } from 'typeorm'
+import { DataStorePresentationDefinitionEntities, DataStorePresentationDefinitionMigrations, PDStore } from '../index'
+import { GetDefinitionsArgs, NonPersistedPresentationDefinitionItem, PresentationDefinitionItem } from '../types'
+
+describe('PDStore tests', (): void => {
+  let dbConnection: DataSource
+  let pdStore: PDStore
+
+  beforeEach(async (): Promise<void> => {
+    dbConnection = await new DataSource({
+      type: 'sqlite',
+      database: ':memory:',
+      logging: ['info'],
+      synchronize: false,
+      migrationsRun: false,
+      migrations: DataStorePresentationDefinitionMigrations,
+      entities: DataStorePresentationDefinitionEntities,
+    }).initialize()
+    await dbConnection.runMigrations()
+    expect(await dbConnection.showMigrations()).toBeFalsy()
+    pdStore = new PDStore(dbConnection)
+  })
+
+  afterEach(async (): Promise<void> => {
+    await dbConnection.destroy()
+  })
+
+  it('should check if definition exists', async (): Promise<void> => {
+    const definition: NonPersistedPresentationDefinitionItem = {
+      definitionId: 'definition1',
+      version: '1.0',
+      definitionPayload: { id: 'definition1', input_descriptors: [] },
+    }
+    const savedDefinition: PresentationDefinitionItem = await pdStore.addDefinition(definition)
+    expect(savedDefinition).toBeDefined()
+
+    const exists: boolean = await pdStore.hasDefinition({ itemId: savedDefinition.id })
+
+    expect(exists).toBeTruthy()
+  })
+
+  it('should check if definitions exist by filter', async (): Promise<void> => {
+    const definition: NonPersistedPresentationDefinitionItem = {
+      definitionId: 'definition1',
+      version: '1.0',
+      definitionPayload: { id: 'definition1', input_descriptors: [] },
+    }
+    const savedDefinition: PresentationDefinitionItem = await pdStore.addDefinition(definition)
+    expect(savedDefinition).toBeDefined()
+
+    const exists: boolean = await pdStore.hasDefinitions({ filter: [{ definitionId: 'definition1' }] })
+
+    expect(exists).toBeTruthy()
+  })
+
+  it('should get definition by id', async (): Promise<void> => {
+    const definition: NonPersistedPresentationDefinitionItem = {
+      definitionId: 'definition1',
+      version: '1.0',
+      definitionPayload: { id: 'definition1', input_descriptors: [] },
+    }
+
+    const savedDefinition: PresentationDefinitionItem = await pdStore.addDefinition(definition)
+    expect(savedDefinition).toBeDefined()
+
+    const result: PresentationDefinitionItem = await pdStore.getDefinition({ itemId: savedDefinition.id })
+
+    expect(result).toBeDefined()
+  })
+
+  it('should throw error when getting definition with unknown id', async (): Promise<void> => {
+    const itemId = 'unknownDefinitionId'
+
+    await expect(pdStore.getDefinition({ itemId })).rejects.toThrow(`No presentation definition item found for id: ${itemId}`)
+  })
+
+  it('should get all definitions', async (): Promise<void> => {
+    const definition1: NonPersistedPresentationDefinitionItem = {
+      definitionId: 'definition1',
+      version: '1.0',
+      definitionPayload: { id: 'definition1', input_descriptors: [] },
+    }
+    const savedDefinition1: PresentationDefinitionItem = await pdStore.addDefinition(definition1)
+    expect(savedDefinition1).toBeDefined()
+
+    const definition2: NonPersistedPresentationDefinitionItem = {
+      definitionId: 'definition2',
+      version: '1.0',
+      definitionPayload: { id: 'definition2', input_descriptors: [] },
+    }
+    const savedDefinition2: PresentationDefinitionItem = await pdStore.addDefinition(definition2)
+    expect(savedDefinition2).toBeDefined()
+
+    const result: Array<PresentationDefinitionItem> = await pdStore.getDefinitions({})
+
+    expect(result).toBeDefined()
+    expect(result.length).toEqual(2)
+  })
+
+  it('should get definitions by filter', async (): Promise<void> => {
+    const definition: NonPersistedPresentationDefinitionItem = {
+      definitionId: 'definition1',
+      version: '1.0',
+      definitionPayload: { id: 'definition1', input_descriptors: [] },
+    }
+    const savedDefinition: PresentationDefinitionItem = await pdStore.addDefinition(definition)
+    expect(savedDefinition).toBeDefined()
+
+    const args: GetDefinitionsArgs = {
+      filter: [{ definitionId: 'definition1' }],
+    }
+    const result: Array<PresentationDefinitionItem> = await pdStore.getDefinitions(args)
+
+    expect(result.length).toEqual(1)
+  })
+
+  it('should add definition', async (): Promise<void> => {
+    const definition: NonPersistedPresentationDefinitionItem = {
+      definitionId: 'definition1',
+      version: '1.0',
+      definitionPayload: { id: 'definition1', input_descriptors: [] },
+    }
+
+    const result: PresentationDefinitionItem = await pdStore.addDefinition(definition)
+
+    expect(result).toBeDefined()
+    expect(result.definitionId).toEqual(definition.definitionId)
+  })
+
+  it('should update definition', async (): Promise<void> => {
+    const definition: NonPersistedPresentationDefinitionItem = {
+      definitionId: 'definition1',
+      version: '1.0',
+      definitionPayload: { id: 'definition1', input_descriptors: [] },
+    }
+    const savedDefinition: PresentationDefinitionItem = await pdStore.addDefinition(definition)
+    expect(savedDefinition).toBeDefined()
+
+    const updatedDefinition: PresentationDefinitionItem = {
+      ...savedDefinition,
+      version: '1.1',
+    }
+
+    await pdStore.updateDefinition(updatedDefinition)
+    const result: PresentationDefinitionItem = await pdStore.getDefinition({ itemId: savedDefinition.id })
+
+    expect(result).toBeDefined()
+    expect(result.version).toEqual('1.1')
+  })
+
+  it('should delete definition', async (): Promise<void> => {
+    const definition: NonPersistedPresentationDefinitionItem = {
+      definitionId: 'definition1',
+      version: '1.0',
+      definitionPayload: { id: 'definition1', input_descriptors: [] },
+    }
+    const savedDefinition: PresentationDefinitionItem = await pdStore.addDefinition(definition)
+    expect(savedDefinition).toBeDefined()
+
+    await pdStore.deleteDefinition({ itemId: savedDefinition.id })
+
+    await expect(pdStore.getDefinition({ itemId: savedDefinition.id })).rejects.toThrow(
+      `No presentation definition item found for id: ${savedDefinition.id}`,
+    )
+  })
+
+  it('should delete definitions by filter', async (): Promise<void> => {
+    const definition1: NonPersistedPresentationDefinitionItem = {
+      definitionId: 'definition1',
+      version: '1.0',
+      definitionPayload: { id: 'definition1', input_descriptors: [] },
+    }
+    const savedDefinition1: PresentationDefinitionItem = await pdStore.addDefinition(definition1)
+    expect(savedDefinition1).toBeDefined()
+
+    const definition2: NonPersistedPresentationDefinitionItem = {
+      definitionId: 'definition2',
+      version: '1.0',
+      definitionPayload: { id: 'definition2', input_descriptors: [] },
+    }
+    const savedDefinition2: PresentationDefinitionItem = await pdStore.addDefinition(definition2)
+    expect(savedDefinition2).toBeDefined()
+
+    const filter = { filter: [{ definitionId: 'definition1' }] }
+    await pdStore.deleteDefinitions(filter)
+
+    const remainingDefinitions: Array<PresentationDefinitionItem> = await pdStore.getDefinitions({})
+    expect(remainingDefinitions.length).toEqual(1)
+    expect(remainingDefinitions[0].definitionId).toEqual('definition2')
+  })
+})

package/src/contact/ContactStore.ts

@@ -1,5 +1,5 @@
 import { OrPromise } from '@sphereon/ssi-types'
-import { DataSource, In, Repository } from 'typeorm'
+import { BaseEntity, DataSource, FindOptionsWhere, In, Repository } from 'typeorm'
 import Debug from 'debug'
 import { AbstractContactStore } from './AbstractContactStore'
 import { PartyEntity } from '../entities/contact/PartyEntity'
@@ -54,6 +54,8 @@ import {
   GetRelationshipArgs,
   GetRelationshipsArgs,
   Identity,
+  MetadataItem,
+  MetadataTypes,
   NonPersistedConnectionConfig,
   NonPersistedContact,
   Party,
@@ -99,21 +101,16 @@ export class ContactStore extends AbstractContactStore {
   }
 
   getParties = async (args?: GetPartiesArgs): Promise<Array<Party>> => {
-    debug(`getParties()`, args)
+    debug('getParties()', args)
     const { filter } = args ?? {}
-    const partyRepository: Repository<PartyEntity> = (await this.dbConnection).getRepository(PartyEntity)
-    const initialResult: Array<PartyEntity> = await partyRepository.find({
-      ...(filter && { where: filter }),
-    })
+    const partyRepository = (await this.dbConnection).getRepository(PartyEntity)
+    const filterConditions = this.buildFilters(filter)
+    const initialResult = await partyRepository.find({ select: ['id'], where: filterConditions })
 
-    const result: Array<PartyEntity> = await partyRepository.find({
-      where: {
-        id: In(initialResult.map((party: PartyEntity) => party.id)),
-      },
-    })
+    // Fetch the complete entities based on the initial result IDs
+    const result = await partyRepository.find({ where: { id: In(initialResult.map((party) => party.id)) } })
     debug(`getParties() resulted in ${result.length} parties`)
-
-    return result.map((party: PartyEntity) => partyFrom(party))
+    return result.map(partyFrom)
   }
 
   addParty = async (args: AddPartyArgs): Promise<Party> => {
@@ -211,18 +208,12 @@ export class ContactStore extends AbstractContactStore {
 
   getIdentities = async (args?: GetIdentitiesArgs): Promise<Array<Identity>> => {
     const { filter } = args ?? {}
-    const identityRepository: Repository<IdentityEntity> = (await this.dbConnection).getRepository(IdentityEntity)
-    const initialResult: Array<IdentityEntity> = await identityRepository.find({
-      ...(filter && { where: filter }),
-    })
-
-    const result: Array<IdentityEntity> = await identityRepository.find({
-      where: {
-        id: In(initialResult.map((identity: IdentityEntity) => identity.id)),
-      },
-    })
+    const identityRepository = (await this.dbConnection).getRepository(IdentityEntity)
+    const filterConditions = this.buildFilters(filter)
+    const initialResult = await identityRepository.find({ select: ['id'], where: filterConditions })
 
-    return result.map((identity: IdentityEntity) => identityFrom(identity))
+    const result = await identityRepository.find({ where: { id: In(initialResult.map((identity) => identity.id)) } })
+    return result.map(identityFrom)
   }
 
   addIdentity = async (args: AddIdentityArgs): Promise<Identity> => {
@@ -622,7 +613,7 @@ export class ContactStore extends AbstractContactStore {
     await physicalAddressRepository.delete(physicalAddressId)
   }
 
-  private hasCorrectConnectionConfig(type: ConnectionType, config: NonPersistedConnectionConfig): boolean {
+  private hasCorrectConnectionConfig = (type: ConnectionType, config: NonPersistedConnectionConfig): boolean => {
     switch (type) {
       case ConnectionType.OPENID_CONNECT:
         return isOpenIdConfig(config)
@@ -633,7 +624,7 @@ export class ContactStore extends AbstractContactStore {
     }
   }
 
-  private hasCorrectPartyType(type: PartyTypeType, contact: NonPersistedContact): boolean {
+  private hasCorrectPartyType = (type: PartyTypeType, contact: NonPersistedContact): boolean => {
     switch (type) {
       case PartyTypeType.NATURAL_PERSON:
         return isNaturalPerson(contact)
@@ -644,7 +635,7 @@ export class ContactStore extends AbstractContactStore {
     }
   }
 
-  private async deleteIdentities(identities: Array<IdentityEntity>): Promise<void> {
+  private deleteIdentities = async (identities: Array<IdentityEntity>): Promise<void> => {
     debug('Removing identities', identities)
 
     const connection: DataSource = await this.dbConnection
@@ -680,7 +671,7 @@ export class ContactStore extends AbstractContactStore {
     })
   }
 
-  private async deleteElectronicAddresses(electronicAddresses: Array<ElectronicAddressEntity>): Promise<void> {
+  private deleteElectronicAddresses = async (electronicAddresses: Array<ElectronicAddressEntity>): Promise<void> => {
     debug('Removing electronic addresses', electronicAddresses)
 
     const electronicAddressRepository: Repository<ElectronicAddressEntity> = (await this.dbConnection).getRepository(ElectronicAddressEntity)
@@ -691,7 +682,7 @@ export class ContactStore extends AbstractContactStore {
     })
   }
 
-  private async deletePhysicalAddresses(physicalAddresses: Array<PhysicalAddressEntity>): Promise<void> {
+  private deletePhysicalAddresses = async (physicalAddresses: Array<PhysicalAddressEntity>): Promise<void> => {
     debug('Removing physical addresses', physicalAddresses)
 
     const physicalAddressRepository: Repository<PhysicalAddressEntity> = (await this.dbConnection).getRepository(PhysicalAddressEntity)
@@ -702,7 +693,7 @@ export class ContactStore extends AbstractContactStore {
     })
   }
 
-  private async assertRelationshipSides(leftId: string, rightId: string): Promise<void> {
+  private assertRelationshipSides = async (leftId: string, rightId: string): Promise<void> => {
     const partyRepository: Repository<PartyEntity> = (await this.dbConnection).getRepository(PartyEntity)
     const leftParty: PartyEntity | null = await partyRepository.findOne({
       where: { id: leftId },
@@ -720,4 +711,57 @@ export class ContactStore extends AbstractContactStore {
       return Promise.reject(Error(`No party found for right side of the relationship, party id: ${rightId}`))
     }
   }
+
+  private buildFilters = <T extends BaseEntity>(filter?: Array<Record<string, any>>): Array<FindOptionsWhere<T>> | FindOptionsWhere<T> => {
+    if (!filter) return {}
+
+    return filter.map((condition) => this.processCondition(condition))
+  }
+
+  private processCondition = (condition: Record<string, any>): Record<string, any> => {
+    const conditionObject: Record<string, any> = {}
+
+    Object.keys(condition).forEach((key) => {
+      const value = condition[key]
+
+      if (key === 'metadata' && value) {
+        conditionObject[key] = this.buildMetadataCondition(value)
+      } else if (typeof value === 'object' && value !== null) {
+        conditionObject[key] = this.processCondition(value)
+      } else {
+        conditionObject[key] = value
+      }
+    })
+
+    return conditionObject
+  }
+
+  private buildMetadataCondition = <T extends MetadataItem<MetadataTypes>>(metadata: Partial<T>): FindOptionsWhere<IMetadataEntity> => {
+    const metadataCondition: FindOptionsWhere<any> = {
+      label: metadata.label,
+    }
+
+    switch (typeof metadata.value) {
+      case 'string':
+        metadataCondition.stringValue = metadata.value as string
+        break
+      case 'number':
+        metadataCondition.numberValue = metadata.value as number
+        break
+      case 'boolean':
+        metadataCondition.boolValue = metadata.value as boolean
+        break
+      case 'object':
+        if (metadata.value instanceof Date) {
+          metadataCondition.dateValue = metadata.value as Date
+        } else {
+          // For now, we only support / implement not-primitive type Date in the entity
+          throw new Error(`Unsupported object type: ${Object.prototype.toString.call(metadata.value).slice(8, -1)} for value ${metadata.value}`) // slice to extract type from string [object String]
+        }
+        break
+      default:
+        throw new Error(`Unsupported value type: ${typeof metadata.value}`)
+    }
+    return metadataCondition
+  }
 }

package/src/entities/contact/BaseContactEntity.ts

@@ -5,12 +5,14 @@ import {
   CreateDateColumn,
   Entity,
   JoinColumn,
+  OneToMany,
   OneToOne,
   PrimaryGeneratedColumn,
   TableInheritance,
   UpdateDateColumn,
 } from 'typeorm'
 import { PartyEntity } from './PartyEntity'
+import { ContactMetadataItemEntity } from './ContactMetadataItemEntity'
 
 @Entity('BaseContact')
 @TableInheritance({ column: { type: 'varchar', name: 'type' } })
@@ -30,6 +32,15 @@ export abstract class BaseContactEntity extends BaseEntity {
   @JoinColumn({ name: 'party_id' })
   party!: PartyEntity
 
+  @OneToMany(() => ContactMetadataItemEntity, (metadata: ContactMetadataItemEntity) => metadata.contact, {
+    cascade: true,
+    onDelete: 'CASCADE',
+    eager: true,
+    nullable: false,
+  })
+  @JoinColumn({ name: 'metadata_id' })
+  metadata!: Array<ContactMetadataItemEntity>
+
   // By default, @UpdateDateColumn in TypeORM updates the timestamp only when the entity's top-level properties change.
   @BeforeInsert()
   @BeforeUpdate()

package/src/entities/contact/ConnectionEntity.ts

@@ -13,6 +13,12 @@ export class ConnectionEntity extends BaseEntity {
   @Column('simple-enum', { name: 'type', enum: ConnectionType, nullable: false })
   type!: ConnectionType
 
+  @Column({name: 'tenant_id', nullable: true})
+  tenantId?: string
+
+  @Column({name: 'owner_id', nullable: true})
+  ownerId?: string
+
   @OneToOne(() => BaseConfigEntity, (config: OpenIdConfigEntity | DidAuthConfigEntity) => config.connection, {
     cascade: true,
     onDelete: 'CASCADE',

package/src/entities/contact/ContactMetadataItemEntity.ts

@@ -0,0 +1,50 @@
+import { Entity, Column, PrimaryGeneratedColumn, BaseEntity, ManyToOne, BeforeInsert, BeforeUpdate } from 'typeorm'
+import { ValidationConstraint } from '../../types'
+import { BaseContactEntity } from './BaseContactEntity'
+import { IsNotEmpty, validate, ValidationError } from 'class-validator'
+import { getConstraint } from '../../utils/ValidatorUtils'
+
+@Entity('ContactMetadata')
+export class ContactMetadataItemEntity extends BaseEntity implements IMetadataEntity {
+  @PrimaryGeneratedColumn('uuid')
+  id!: string
+
+  @Column({ name: 'label', length: 255, nullable: false })
+  @IsNotEmpty({ message: 'Blank metadata labels are not allowed' })
+  label!: string
+
+  @Column({ name: 'valueType', nullable: false })
+  @IsNotEmpty({ message: 'valueType must not be empty' })
+  valueType!: string
+
+  @Column({ name: 'stringValue', length: 255, nullable: true })
+  stringValue?: string
+
+  @Column({ name: 'numberValue', nullable: true })
+  numberValue?: number
+
+  @Column({ name: 'dateValue', nullable: true })
+  dateValue?: Date
+
+  @Column({ name: 'boolValue', nullable: true })
+  boolValue?: boolean
+
+  @ManyToOne(() => BaseContactEntity, (contact: BaseContactEntity) => contact.metadata, {
+    cascade: ['insert', 'update'],
+    onDelete: 'CASCADE',
+  })
+  contact!: BaseContactEntity
+
+  @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/CorrelationIdentifierEntity.ts

@@ -16,6 +16,12 @@ export class CorrelationIdentifierEntity extends BaseEntity {
   @IsNotEmpty({ message: 'Blank correlation ids are not allowed' })
   correlationId!: string
 
+  @Column({name: 'owner_id', nullable: true})
+  ownerId?: string
+
+  @Column({name: 'tenant_id', nullable: true})
+  tenantId?: string
+
   @OneToOne(() => IdentityEntity, (identity: IdentityEntity) => identity.identifier, {
     onDelete: 'CASCADE',
   })

package/src/entities/contact/DidAuthConfigEntity.ts

@@ -11,4 +11,10 @@ export class DidAuthConfigEntity extends BaseConfigEntity {
 
   @Column({ name: 'session_id', length: 255, nullable: false })
   sessionId!: string
+
+  @Column({name: 'owner_id', nullable: true})
+  ownerId?: string
+
+  @Column({name: 'tenant_id', nullable: true})
+  tenantId?: string
 }

package/src/entities/contact/ElectronicAddressEntity.ts

@@ -35,6 +35,12 @@ export class ElectronicAddressEntity extends BaseEntity {
   @Column({ name: 'partyId', nullable: true })
   partyId?: string
 
+  @Column({name: 'owner_id', nullable: true})
+  ownerId?: string
+
+  @Column({name: 'tenant_id', nullable: true})
+  tenantId?: string
+
   @CreateDateColumn({ name: 'created_at', nullable: false })
   createdAt!: Date
 

package/src/entities/contact/IMetadataEntity.ts

@@ -0,0 +1,7 @@
+interface IMetadataEntity { // TODO move to types
+  label: string
+  stringValue?: string
+  numberValue?: number
+  dateValue?: Date
+  boolValue?: boolean
+}

package/src/entities/contact/IdentityEntity.ts

@@ -16,7 +16,7 @@ import { IsNotEmpty, validate, ValidationError } from 'class-validator'
 import { CorrelationIdentifierEntity } from './CorrelationIdentifierEntity'
 import { ConnectionEntity } from './ConnectionEntity'
 import { IdentityMetadataItemEntity } from './IdentityMetadataItemEntity'
-import { IdentityRole, ValidationConstraint } from '../../types'
+import { CredentialRole, IdentityOrigin, ValidationConstraint } from '../../types'
 import { PartyEntity } from './PartyEntity'
 import { getConstraint } from '../../utils/ValidatorUtils'
 
@@ -34,8 +34,17 @@ export class IdentityEntity extends BaseEntity {
   @IsNotEmpty({ message: 'Blank aliases are not allowed' })
   alias!: string
 
+  @Column('simple-enum', { name: 'origin', enum: IdentityOrigin, nullable: false })
+  origin!: IdentityOrigin
+
+  @Column({ name: 'owner_id', nullable: true })
+  ownerId?: string
+
+  @Column({ name: 'tenant_id', nullable: true })
+  tenantId?: string
+
   @Column('simple-array', { name: 'roles', nullable: false })
-  roles!: Array<IdentityRole>
+  roles!: Array<CredentialRole>
 
   @OneToOne(() => CorrelationIdentifierEntity, (identifier: CorrelationIdentifierEntity) => identifier.identity, {
     cascade: true,

package/src/entities/contact/IdentityMetadataItemEntity.ts

@@ -5,7 +5,7 @@ import { IsNotEmpty, validate, ValidationError } from 'class-validator'
 import { getConstraint } from '../../utils/ValidatorUtils'
 
 @Entity('IdentityMetadata')
-export class IdentityMetadataItemEntity extends BaseEntity {
+export class IdentityMetadataItemEntity extends BaseEntity implements IMetadataEntity {
   @PrimaryGeneratedColumn('uuid')
   id!: string
 
@@ -13,9 +13,21 @@ export class IdentityMetadataItemEntity extends BaseEntity {
   @IsNotEmpty({ message: 'Blank metadata labels are not allowed' })
   label!: string
 
-  @Column({ name: 'value', length: 255, nullable: false })
-  @IsNotEmpty({ message: 'Blank metadata values are not allowed' })
-  value!: string
+  @Column({ name: 'valueType', nullable: false })
+  @IsNotEmpty({ message: 'valueType must not be empty' })
+  valueType!: string
+
+  @Column({ name: 'stringValue', length: 255, nullable: true })
+  stringValue?: string
+
+  @Column({ name: 'numberValue', nullable: true })
+  numberValue?: number
+
+  @Column({ name: 'dateValue', nullable: true })
+  dateValue?: Date
+
+  @Column({ name: 'boolValue', nullable: true })
+  boolValue?: boolean
 
   @ManyToOne(() => IdentityEntity, (identity: IdentityEntity) => identity.metadata, { cascade: ['insert', 'update'], onDelete: 'CASCADE' })
   identity!: IdentityEntity

package/src/entities/contact/NaturalPersonEntity.ts

@@ -23,6 +23,12 @@ export class NaturalPersonEntity extends BaseContactEntity {
   @IsNotEmpty({ message: 'Blank display names are not allowed' })
   displayName!: string
 
+  @Column({name: 'owner_id', nullable: true})
+  ownerId?: string
+
+  @Column({name: 'tenant_id', nullable: true})
+  tenantId?: string
+
   @BeforeInsert()
   @BeforeUpdate()
   async validate(): Promise<void> {

package/src/entities/contact/OpenIdConfigEntity.ts

@@ -23,4 +23,10 @@ export class OpenIdConfigEntity extends BaseConfigEntity {
 
   @Column('text', { name: 'client_auth_method', nullable: false })
   clientAuthMethod!: 'basic' | 'post' | undefined
+
+  @Column({name: 'owner_id', nullable: true})
+  ownerId?: string
+
+  @Column({name: 'tenant_id', nullable: true})
+  tenantId?: string
 }

package/src/entities/contact/OrganizationEntity.ts

@@ -15,6 +15,12 @@ export class OrganizationEntity extends BaseContactEntity {
   @IsNotEmpty({ message: 'Blank display names are not allowed' })
   displayName!: string
 
+  @Column({name: 'owner_id', nullable: true})
+  ownerId?: string
+
+  @Column({name: 'tenant_id', nullable: true})
+  tenantId?: string
+
   @OneToOne(() => PartyEntity)
   @JoinColumn({ name: 'party_id' })
   party!: PartyEntity

package/src/entities/contact/PartyEntity.ts

@@ -30,6 +30,12 @@ export class PartyEntity extends BaseEntity {
   @Column({ name: 'uri', length: 255, nullable: true })
   uri?: string
 
+  @Column({name: 'owner_id', nullable: true})
+  ownerId?: string
+
+  @Column({name: 'tenant_id', nullable: true})
+  tenantId?: string
+
   @OneToMany(() => IdentityEntity, (identity: IdentityEntity) => identity.party, {
     cascade: true,
     onDelete: 'CASCADE',

package/src/entities/contact/PartyRelationshipEntity.ts

@@ -38,6 +38,12 @@ export class PartyRelationshipEntity {
   @Column({ name: 'right_id', nullable: false })
   rightId!: string
 
+  @Column({name: 'owner_id', nullable: true})
+  ownerId?: string
+
+  @Column({name: 'tenant_id', nullable: true})
+  tenantId?: string
+
   @CreateDateColumn({ name: 'created_at', nullable: false })
   createdAt!: Date
 

package/src/entities/contact/PartyTypeEntity.ts

@@ -11,21 +11,21 @@ export class PartyTypeEntity {
   @PrimaryGeneratedColumn('uuid')
   id!: string
 
-  @Column('simple-enum', { name: 'type', enum: PartyTypeType, nullable: false, unique: false })
+  @Column('simple-enum', { name: 'type', enum: PartyTypeType, nullable: false })
   type!: PartyTypeType
 
-  @Column('simple-enum', { name: 'origin', enum: PartyOrigin, default: 'EXTERNAL', nullable: false, unique: false })
+  @Column('simple-enum', { name: 'origin', enum: PartyOrigin, nullable: false, unique: false })
   origin!: PartyOrigin
 
   @Column({ name: 'name', length: 255, nullable: false, unique: true })
   @IsNotEmpty({ message: 'Blank names are not allowed' })
   name!: string
 
-  @Column({ name: 'description', length: 255, nullable: true, unique: false })
+  @Column({ name: 'description', length: 255, nullable: true })
   @Validate(IsNonEmptyStringConstraint, { message: 'Blank descriptions are not allowed' })
   description?: string
 
-  @Column({ name: 'tenant_id', length: 255, nullable: false, unique: false })
+  @Column({ name: 'tenant_id', length: 255, nullable: true })
   @IsNotEmpty({ message: "Blank tenant id's are not allowed" })
   tenantId!: string