@sphereon/ssi-sdk.data-store 0.15.2-next.5 → 0.15.2-next.77

package/src/__tests__/contact.entities.test.ts

@@ -1,24 +1,45 @@
-import { DataSource } from 'typeorm'
-
+import { DataSource, FindOptionsWhere } from 'typeorm'
+
+import { DataStoreContactEntities, DataStoreMigrations } from '../index'
+import { NaturalPersonEntity } from '../entities/contact/NaturalPersonEntity'
+import { OrganizationEntity } from '../entities/contact/OrganizationEntity'
+import { PartyRelationshipEntity } from '../entities/contact/PartyRelationshipEntity'
+import { PartyTypeEntity } from '../entities/contact/PartyTypeEntity'
+import { PartyEntity } from '../entities/contact/PartyEntity'
+import { IdentityEntity } from '../entities/contact/IdentityEntity'
+import { OpenIdConfigEntity } from '../entities/contact/OpenIdConfigEntity'
+import { DidAuthConfigEntity } from '../entities/contact/DidAuthConfigEntity'
+import { ConnectionEntity } from '../entities/contact/ConnectionEntity'
+import { CorrelationIdentifierEntity } from '../entities/contact/CorrelationIdentifierEntity'
+import { IdentityMetadataItemEntity } from '../entities/contact/IdentityMetadataItemEntity'
+import { BaseContactEntity } from '../entities/contact/BaseContactEntity'
 import {
+  NonPersistedParty,
+  PartyTypeEnum,
+  NaturalPerson,
+  Organization,
+  IdentityRoleEnum,
   CorrelationIdentifierEnum,
-  DataStoreContactEntities,
-  DataStoreMigrations,
-  contactEntityFrom,
+  ConnectionTypeEnum,
+  NonPersistedPartyType,
+  NonPersistedOrganization,
+  NonPersistedNaturalPerson,
+  NonPersistedConnection,
+  NonPersistedIdentity,
+  NonPersistedDidAuthConfig,
+  NonPersistedOpenIdConfig,
+} from '../types'
+import {
   connectionEntityFrom,
-  identityEntityFrom,
   didAuthConfigEntityFrom,
+  identityEntityFrom,
+  naturalPersonEntityFrom,
   openIdConfigEntityFrom,
-  ContactEntity,
-  IdentityEntity,
-  ConnectionTypeEnum,
-  OpenIdConfigEntity,
-  DidAuthConfigEntity,
-  ConnectionEntity,
-  CorrelationIdentifierEntity,
-  IdentityMetadataItemEntity,
-  IdentityRoleEnum,
-} from '../index'
+  organizationEntityFrom,
+  partyEntityFrom,
+  partyRelationshipEntityFrom,
+  partyTypeEntityFrom,
+} from '../utils/contact/MappingUtils'
 
 describe('Database entities tests', (): void => {
   let dbConnection: DataSource
@@ -27,7 +48,7 @@ describe('Database entities tests', (): void => {
     dbConnection = await new DataSource({
       type: 'sqlite',
       database: ':memory:',
-      //logging: 'all',
+      logging: 'all',
       migrationsRun: false,
       migrations: DataStoreMigrations,
       synchronize: false,
@@ -41,98 +62,333 @@ describe('Database entities tests', (): void => {
     await (await dbConnection).destroy()
   })
 
-  it('Should save contact to database', async (): Promise<void> => {
-    const contact = {
-      name: 'test_name',
-      alias: 'test_alias',
+  it('Should save person party to database', async (): Promise<void> => {
+    const party: NonPersistedParty = {
       uri: 'example.com',
+      partyType: {
+        type: PartyTypeEnum.NATURAL_PERSON,
+        tenantId: '0605761c-4113-4ce5-a6b2-9cbae2f9d289',
+        name: 'example_name',
+      },
+      contact: {
+        firstName: 'example_first_name',
+        middleName: 'example_middle_name',
+        lastName: 'example_last_name',
+        displayName: 'example_display_name',
+      },
     }
 
-    const contactEntity: ContactEntity = contactEntityFrom(contact)
-    await dbConnection.getRepository(ContactEntity).save(contactEntity)
+    const partyEntity: PartyEntity = partyEntityFrom(party)
+    await dbConnection.getRepository(PartyEntity).save(partyEntity, {
+      transaction: true,
+    })
 
-    const fromDb = await dbConnection.getRepository(ContactEntity).findOne({
-      where: { name: contact.name },
+    const fromDb: PartyEntity | null = await dbConnection.getRepository(PartyEntity).findOne({
+      where: { id: partyEntity.id },
     })
 
     expect(fromDb).toBeDefined()
     expect(fromDb?.identities?.length).toEqual(0)
-    expect(fromDb?.name).toEqual(contact.name)
-    expect(fromDb?.alias).toEqual(contact.alias)
-    expect(fromDb?.uri).toEqual(contact.uri)
+    expect(fromDb?.uri).toEqual(party.uri)
+    expect(fromDb?.partyType).toBeDefined()
+    expect(fromDb?.partyType.type).toEqual(party.partyType.type)
+    expect(fromDb?.partyType.tenantId).toEqual(party.partyType.tenantId)
+    expect(fromDb?.partyType.name).toEqual(party.partyType.name)
+    expect(fromDb?.contact).toBeDefined()
+    expect((<NaturalPersonEntity>fromDb?.contact).firstName).toEqual((<NaturalPerson>party.contact).firstName)
+    expect((<NaturalPersonEntity>fromDb?.contact).middleName).toEqual((<NaturalPerson>party.contact).middleName)
+    expect((<NaturalPersonEntity>fromDb?.contact).lastName).toEqual((<NaturalPerson>party.contact).lastName)
+    expect((<NaturalPersonEntity>fromDb?.contact).displayName).toEqual((<NaturalPerson>party.contact).displayName)
   })
 
-  it('should throw error when saving contact with blank name', async (): Promise<void> => {
-    const contact = {
-      name: '',
-      alias: 'test_alias',
+  it('Should save organization party to database', async (): Promise<void> => {
+    const party: NonPersistedParty = {
       uri: 'example.com',
+      partyType: {
+        type: PartyTypeEnum.ORGANIZATION,
+        tenantId: '0605761c-4113-4ce5-a6b2-9cbae2f9d289',
+        name: 'example_name',
+      },
+      contact: {
+        legalName: 'example_legal_name',
+        displayName: 'example_display_name',
+      },
     }
 
-    const contactEntity: ContactEntity = contactEntityFrom(contact)
+    const partyEntity: PartyEntity = partyEntityFrom(party)
+    await dbConnection.getRepository(PartyEntity).save(partyEntity, {
+      transaction: true,
+    })
+
+    const fromDb: PartyEntity | null = await dbConnection.getRepository(PartyEntity).findOne({
+      where: { id: partyEntity.id },
+    })
 
-    await expect(dbConnection.getRepository(ContactEntity).save(contactEntity)).rejects.toThrow('Blank names are not allowed')
+    expect(fromDb).toBeDefined()
+    expect(fromDb?.identities?.length).toEqual(0)
+    expect(fromDb?.uri).toEqual(party.uri)
+    expect(fromDb?.partyType).toBeDefined()
+    expect(fromDb?.partyType.type).toEqual(party.partyType.type)
+    expect(fromDb?.partyType.tenantId).toEqual(party.partyType.tenantId)
+    expect(fromDb?.partyType.name).toEqual(party.partyType.name)
+    expect(fromDb?.contact).toBeDefined()
+    expect((<OrganizationEntity>fromDb?.contact).legalName).toEqual((<Organization>party.contact).legalName)
+    expect((<OrganizationEntity>fromDb?.contact).displayName).toEqual((<Organization>party.contact).displayName)
   })
 
-  it('should throw error when saving contact with blank alias', async (): Promise<void> => {
-    const contact = {
-      name: 'test_name',
-      alias: '',
+  it('Should result in party relationship for the owner side only', async (): Promise<void> => {
+    const party1: NonPersistedParty = {
+      uri: 'example1.com',
+      partyType: {
+        type: PartyTypeEnum.NATURAL_PERSON,
+        tenantId: '0605761c-4113-4ce5-a6b2-9cbae2f9d289',
+        name: 'example_name1',
+      },
+      contact: {
+        firstName: 'example_first_name1',
+        middleName: 'example_middle_name1',
+        lastName: 'example_last_name1',
+        displayName: 'example_display_name1',
+      },
+    }
+
+    const partyEntity1: PartyEntity = partyEntityFrom(party1)
+    const savedParty1: PartyEntity = await dbConnection.getRepository(PartyEntity).save(partyEntity1, {
+      transaction: true,
+    })
+
+    const party2: NonPersistedParty = {
+      uri: 'example2.com',
+      partyType: {
+        type: PartyTypeEnum.NATURAL_PERSON,
+        tenantId: '0605761c-4113-4ce5-a6b2-9cbae2f9d288',
+        name: 'example_name2',
+      },
+      contact: {
+        firstName: 'example_first_name2',
+        middleName: 'example_middle_name2',
+        lastName: 'example_last_name2',
+        displayName: 'example_display_name2',
+      },
+    }
+
+    const partyEntity2: PartyEntity = partyEntityFrom(party2)
+    const savedParty2: PartyEntity = await dbConnection.getRepository(PartyEntity).save(partyEntity2, {
+      transaction: true,
+    })
+
+    const relationship: PartyRelationshipEntity = partyRelationshipEntityFrom({
+      leftId: savedParty1.id,
+      rightId: savedParty2.id,
+    })
+
+    await dbConnection.getRepository(PartyRelationshipEntity).save(relationship, {
+      transaction: true,
+    })
+
+    const fromDb1: PartyEntity | null = await dbConnection.getRepository(PartyEntity).findOne({
+      where: { id: savedParty1.id },
+    })
+
+    const fromDb2: PartyEntity | null = await dbConnection.getRepository(PartyEntity).findOne({
+      where: { id: savedParty2.id },
+    })
+
+    expect(fromDb1).toBeDefined()
+    expect(fromDb1?.relationships.length).toEqual(1)
+    expect(fromDb2).toBeDefined()
+    expect(fromDb2?.relationships.length).toEqual(0)
+  })
+
+  it('should throw error when saving person party with blank first name', async (): Promise<void> => {
+    const party: NonPersistedParty = {
       uri: 'example.com',
+      partyType: {
+        type: PartyTypeEnum.NATURAL_PERSON,
+        tenantId: '0605761c-4113-4ce5-a6b2-9cbae2f9d289',
+        name: 'example_name',
+      },
+      contact: {
+        firstName: '',
+        middleName: 'example_middle_name1',
+        lastName: 'example_last_name1',
+        displayName: 'example_display_name1',
+      },
     }
 
-    const contactEntity: ContactEntity = contactEntityFrom(contact)
+    const partyEntity: PartyEntity = partyEntityFrom(party)
 
-    await expect(dbConnection.getRepository(ContactEntity).save(contactEntity)).rejects.toThrow('Blank aliases are not allowed')
+    await expect(dbConnection.getRepository(PartyEntity).save(partyEntity)).rejects.toThrowError('Blank first names are not allowed')
   })
 
-  it('Should enforce unique name for a contact', async (): Promise<void> => {
-    const contactName = 'non_unique_name'
-    const contact1 = {
-      name: contactName,
-      alias: 'unique_alias1',
+  it('should throw error when saving person party with blank middle name', async (): Promise<void> => {
+    const party: NonPersistedParty = {
       uri: 'example.com',
+      partyType: {
+        type: PartyTypeEnum.NATURAL_PERSON,
+        tenantId: '0605761c-4113-4ce5-a6b2-9cbae2f9d289',
+        name: 'example_name',
+      },
+      contact: {
+        firstName: 'example_first_name',
+        middleName: '',
+        lastName: 'example_last_name',
+        displayName: 'example_display_name',
+      },
     }
-    const contact1Entity: ContactEntity = contactEntityFrom(contact1)
-    await dbConnection.getRepository(ContactEntity).save(contact1Entity)
 
-    const contact2 = {
-      name: contactName,
-      alias: 'unique_alias2',
+    const partyEntity: PartyEntity = partyEntityFrom(party)
+
+    await expect(dbConnection.getRepository(PartyEntity).save(partyEntity)).rejects.toThrowError('Blank middle names are not allowed')
+  })
+
+  it('should throw error when saving person party with blank last name', async (): Promise<void> => {
+    const party: NonPersistedParty = {
       uri: 'example.com',
+      partyType: {
+        type: PartyTypeEnum.NATURAL_PERSON,
+        tenantId: '0605761c-4113-4ce5-a6b2-9cbae2f9d289',
+        name: 'example_name',
+      },
+      contact: {
+        firstName: 'example_first_name',
+        middleName: 'example_middle_name',
+        lastName: '',
+        displayName: 'example_display_name',
+      },
     }
-    const contact2Entity: ContactEntity = contactEntityFrom(contact2)
 
-    await expect(dbConnection.getRepository(ContactEntity).save(contact2Entity)).rejects.toThrowError(
-      'SQLITE_CONSTRAINT: UNIQUE constraint failed: Contact.name'
-    )
+    const partyEntity: PartyEntity = partyEntityFrom(party)
+
+    await expect(dbConnection.getRepository(PartyEntity).save(partyEntity)).rejects.toThrowError('Blank last names are not allowed')
   })
 
-  it('Should enforce unique alias for a contact', async (): Promise<void> => {
-    const alias = 'non_unique_alias'
-    const contact1 = {
-      name: 'unique_name1',
-      alias,
+  it('should throw error when saving person party with blank display name', async (): Promise<void> => {
+    const party: NonPersistedParty = {
       uri: 'example.com',
+      partyType: {
+        type: PartyTypeEnum.NATURAL_PERSON,
+        tenantId: '0605761c-4113-4ce5-a6b2-9cbae2f9d289',
+        name: 'example_name',
+      },
+      contact: {
+        firstName: 'example_first_name',
+        middleName: 'example_middle_name',
+        lastName: 'example_last_name',
+        displayName: '',
+      },
     }
-    const contact1Entity: ContactEntity = contactEntityFrom(contact1)
-    await dbConnection.getRepository(ContactEntity).save(contact1Entity)
 
-    const contact2 = {
-      name: 'unique_name2',
-      alias,
+    const partyEntity: PartyEntity = partyEntityFrom(party)
+
+    await expect(dbConnection.getRepository(PartyEntity).save(partyEntity)).rejects.toThrowError('Blank display names are not allowed')
+  })
+
+  it('should throw error when saving organization party with blank legal name', async (): Promise<void> => {
+    const party: NonPersistedParty = {
       uri: 'example.com',
+      partyType: {
+        type: PartyTypeEnum.ORGANIZATION,
+        tenantId: '0605761c-4113-4ce5-a6b2-9cbae2f9d289',
+        name: 'example_name',
+      },
+      contact: {
+        legalName: '',
+        displayName: 'example_legal_name',
+      },
     }
-    const contact2Entity: ContactEntity = contactEntityFrom(contact2)
 
-    await expect(dbConnection.getRepository(ContactEntity).save(contact2Entity)).rejects.toThrowError(
-      'SQLITE_CONSTRAINT: UNIQUE constraint failed: Contact.alias'
-    )
+    const partyEntity: PartyEntity = partyEntityFrom(party)
+
+    await expect(dbConnection.getRepository(PartyEntity).save(partyEntity)).rejects.toThrowError('Blank legal names are not allowed')
+  })
+
+  it('should throw error when saving organization party with blank display name', async (): Promise<void> => {
+    const party: NonPersistedParty = {
+      uri: 'example.com',
+      partyType: {
+        type: PartyTypeEnum.ORGANIZATION,
+        tenantId: '0605761c-4113-4ce5-a6b2-9cbae2f9d289',
+        name: 'example_name',
+      },
+      contact: {
+        legalName: 'example_first_name',
+        displayName: '',
+      },
+    }
+
+    const partyEntity: PartyEntity = partyEntityFrom(party)
+
+    await expect(dbConnection.getRepository(PartyEntity).save(partyEntity)).rejects.toThrowError('Blank display names are not allowed')
+  })
+
+  it('should throw error when saving party with blank party type name', async (): Promise<void> => {
+    const party: NonPersistedParty = {
+      uri: 'example.com',
+      partyType: {
+        type: PartyTypeEnum.NATURAL_PERSON,
+        tenantId: '0605761c-4113-4ce5-a6b2-9cbae2f9d289',
+        name: '',
+      },
+      contact: {
+        firstName: 'example_first_name',
+        middleName: 'example_middle_name',
+        lastName: 'example_last_name',
+        displayName: 'example_display_name',
+      },
+    }
+
+    const partyEntity: PartyEntity = partyEntityFrom(party)
+
+    await expect(dbConnection.getRepository(PartyEntity).save(partyEntity)).rejects.toThrowError('Blank names are not allowed')
+  })
+
+  it('should throw error when saving party with blank party type description', async (): Promise<void> => {
+    const party: NonPersistedParty = {
+      uri: 'example.com',
+      partyType: {
+        type: PartyTypeEnum.NATURAL_PERSON,
+        tenantId: '0605761c-4113-4ce5-a6b2-9cbae2f9d289',
+        name: 'example_name',
+        description: '',
+      },
+      contact: {
+        firstName: 'example_first_name',
+        middleName: 'example_middle_name',
+        lastName: 'example_last_name',
+        displayName: 'example_display_name',
+      },
+    }
+
+    const partyEntity: PartyEntity = partyEntityFrom(party)
+
+    await expect(dbConnection.getRepository(PartyEntity).save(partyEntity)).rejects.toThrowError('Blank descriptions are not allowed')
+  })
+
+  it('should throw error when saving party with blank party type tenant id', async (): Promise<void> => {
+    const party: NonPersistedParty = {
+      uri: 'example.com',
+      partyType: {
+        type: PartyTypeEnum.NATURAL_PERSON,
+        tenantId: '',
+        name: 'example_name',
+      },
+      contact: {
+        firstName: 'example_first_name',
+        middleName: 'example_middle_name',
+        lastName: 'example_last_name',
+        displayName: 'example_display_name',
+      },
+    }
+
+    const partyEntity: PartyEntity = partyEntityFrom(party)
+
+    await expect(dbConnection.getRepository(PartyEntity).save(partyEntity)).rejects.toThrowError("Blank tenant id's are not allowed")
   })
 
   it('Should enforce unique alias for an identity', async (): Promise<void> => {
     const alias = 'non_unique_alias'
-    const identity1 = {
+    const identity1: NonPersistedIdentity = {
       alias,
       roles: [IdentityRoleEnum.ISSUER, IdentityRoleEnum.VERIFIER],
       identifier: {
@@ -143,7 +399,7 @@ describe('Database entities tests', (): void => {
     const identity1Entity: IdentityEntity = identityEntityFrom(identity1)
     await dbConnection.getRepository(IdentityEntity).save(identity1Entity)
 
-    const identity2 = {
+    const identity2: NonPersistedIdentity = {
       alias: alias,
       roles: [IdentityRoleEnum.ISSUER, IdentityRoleEnum.VERIFIER],
       identifier: {
@@ -159,7 +415,7 @@ describe('Database entities tests', (): void => {
 
   it('Should enforce unique correlationId for a identity', async (): Promise<void> => {
     const correlationId = 'non_unique_correlationId'
-    const identity1 = {
+    const identity1: NonPersistedIdentity = {
       alias: 'unique_alias1',
       roles: [IdentityRoleEnum.ISSUER, IdentityRoleEnum.VERIFIER],
       identifier: {
@@ -170,7 +426,7 @@ describe('Database entities tests', (): void => {
     const identity1Entity: IdentityEntity = identityEntityFrom(identity1)
     await dbConnection.getRepository(IdentityEntity).save(identity1Entity)
 
-    const identity2 = {
+    const identity2: NonPersistedIdentity = {
       alias: 'unique_alias2',
       roles: [IdentityRoleEnum.ISSUER, IdentityRoleEnum.VERIFIER],
       identifier: {
@@ -186,7 +442,7 @@ describe('Database entities tests', (): void => {
 
   it('Should save identity to database', async (): Promise<void> => {
     const correlationId = 'example_did'
-    const identity = {
+    const identity: NonPersistedIdentity = {
       alias: correlationId,
       roles: [IdentityRoleEnum.ISSUER, IdentityRoleEnum.VERIFIER],
       identifier: {
@@ -199,7 +455,7 @@ describe('Database entities tests', (): void => {
 
     await dbConnection.getRepository(IdentityEntity).save(identityEntity)
 
-    const fromDb = await dbConnection.getRepository(IdentityEntity).findOne({
+    const fromDb: IdentityEntity | null = await dbConnection.getRepository(IdentityEntity).findOne({
       where: {
         identifier: {
           correlationId,
@@ -215,7 +471,7 @@ describe('Database entities tests', (): void => {
   })
 
   it('should throw error when saving identity with blank alias', async (): Promise<void> => {
-    const identity = {
+    const identity: NonPersistedIdentity = {
       alias: '',
       roles: [IdentityRoleEnum.ISSUER, IdentityRoleEnum.VERIFIER],
       identifier: {
@@ -226,11 +482,11 @@ describe('Database entities tests', (): void => {
 
     const identityEntity: IdentityEntity = identityEntityFrom(identity)
 
-    await expect(dbConnection.getRepository(IdentityEntity).save(identityEntity)).rejects.toThrow('Blank aliases are not allowed')
+    await expect(dbConnection.getRepository(IdentityEntity).save(identityEntity)).rejects.toThrowError('Blank aliases are not allowed')
   })
 
   it('should throw error when saving identity with blank correlation id', async (): Promise<void> => {
-    const identity = {
+    const identity: NonPersistedIdentity = {
       alias: 'example_did',
       roles: [IdentityRoleEnum.ISSUER, IdentityRoleEnum.VERIFIER],
       identifier: {
@@ -241,12 +497,12 @@ describe('Database entities tests', (): void => {
 
     const identityEntity: IdentityEntity = identityEntityFrom(identity)
 
-    await expect(dbConnection.getRepository(IdentityEntity).save(identityEntity)).rejects.toThrow('Blank correlation ids are not allowed')
+    await expect(dbConnection.getRepository(IdentityEntity).save(identityEntity)).rejects.toThrowError('Blank correlation ids are not allowed')
   })
 
   it('should throw error when saving identity with blank metadata label', async (): Promise<void> => {
     const correlationId = 'example_did'
-    const identity = {
+    const identity: NonPersistedIdentity = {
       alias: correlationId,
       roles: [IdentityRoleEnum.ISSUER, IdentityRoleEnum.VERIFIER],
       identifier: {
@@ -263,12 +519,12 @@ describe('Database entities tests', (): void => {
 
     const identityEntity: IdentityEntity = identityEntityFrom(identity)
 
-    await expect(dbConnection.getRepository(IdentityEntity).save(identityEntity)).rejects.toThrow('Blank metadata labels are not allowed')
+    await expect(dbConnection.getRepository(IdentityEntity).save(identityEntity)).rejects.toThrowError('Blank metadata labels are not allowed')
   })
 
   it('should throw error when saving identity with blank metadata value', async (): Promise<void> => {
     const correlationId = 'example_did'
-    const identity = {
+    const identity: NonPersistedIdentity = {
       alias: correlationId,
       roles: [IdentityRoleEnum.ISSUER, IdentityRoleEnum.VERIFIER],
       identifier: {
@@ -285,12 +541,12 @@ describe('Database entities tests', (): void => {
 
     const identityEntity: IdentityEntity = identityEntityFrom(identity)
 
-    await expect(dbConnection.getRepository(IdentityEntity).save(identityEntity)).rejects.toThrow('Blank metadata values are not allowed')
+    await expect(dbConnection.getRepository(IdentityEntity).save(identityEntity)).rejects.toThrowError('Blank metadata values are not allowed')
   })
 
   it('Should save identity with openid connection to database', async (): Promise<void> => {
     const correlationId = 'example.com'
-    const identity = {
+    const identity: NonPersistedIdentity = {
       alias: correlationId,
       roles: [IdentityRoleEnum.ISSUER, IdentityRoleEnum.VERIFIER],
       identifier: {
@@ -306,7 +562,7 @@ describe('Database entities tests', (): void => {
           issuer: 'https://example.com/app-test',
           redirectUrl: 'app:/callback',
           dangerouslyAllowInsecureHttpRequests: true,
-          clientAuthMethod: 'post' as const,
+          clientAuthMethod: <const>'post',
         },
       },
     }
@@ -315,7 +571,7 @@ describe('Database entities tests', (): void => {
 
     await dbConnection.getRepository(IdentityEntity).save(identityEntity)
 
-    const fromDb = await dbConnection.getRepository(IdentityEntity).findOne({
+    const fromDb: IdentityEntity | null = await dbConnection.getRepository(IdentityEntity).findOne({
       where: {
         identifier: {
           correlationId,
@@ -328,14 +584,14 @@ describe('Database entities tests', (): void => {
     expect(fromDb?.identifier).toBeDefined()
     expect(fromDb?.identifier.correlationId).toEqual(identity.identifier.correlationId)
     expect(fromDb?.identifier.type).toEqual(identity.identifier.type)
-    expect(fromDb?.connection?.type).toEqual(identity.connection.type)
+    expect(fromDb?.connection?.type).toEqual(identity.connection?.type)
     expect(fromDb?.connection?.config).toBeDefined()
-    expect((fromDb?.connection?.config as OpenIdConfigEntity).clientId).toEqual(identity.connection.config.clientId)
+    expect((<OpenIdConfigEntity>fromDb?.connection?.config).clientId).toEqual((<NonPersistedOpenIdConfig>identity.connection?.config).clientId)
   })
 
   it('Should save identity with didauth connection to database', async (): Promise<void> => {
     const correlationId = 'example.com'
-    const identity = {
+    const identity: NonPersistedIdentity = {
       alias: correlationId,
       roles: [IdentityRoleEnum.ISSUER, IdentityRoleEnum.VERIFIER],
       identifier: {
@@ -362,7 +618,7 @@ describe('Database entities tests', (): void => {
 
     await dbConnection.getRepository(IdentityEntity).save(identityEntity)
 
-    const fromDb = await dbConnection.getRepository(IdentityEntity).findOne({
+    const fromDb: IdentityEntity | null = await dbConnection.getRepository(IdentityEntity).findOne({
       where: {
         identifier: {
           correlationId,
@@ -375,13 +631,15 @@ describe('Database entities tests', (): void => {
     expect(fromDb?.identifier).toBeDefined()
     expect(fromDb?.identifier.correlationId).toEqual(identity.identifier.correlationId)
     expect(fromDb?.identifier.type).toEqual(identity.identifier.type)
-    expect(fromDb?.connection?.type).toEqual(identity.connection.type)
+    expect(fromDb?.connection?.type).toEqual(identity.connection?.type)
     expect(fromDb?.connection?.config).toBeDefined()
-    expect((fromDb?.connection?.config as DidAuthConfigEntity).identifier).toEqual(identity.connection.config.identifier.did)
+    expect((<DidAuthConfigEntity>fromDb?.connection?.config).identifier).toEqual(
+      (<NonPersistedDidAuthConfig>identity.connection?.config).identifier.did
+    )
   })
 
   it('Should save connection with openid config to database', async (): Promise<void> => {
-    const connection = {
+    const connection: NonPersistedConnection = {
       type: ConnectionTypeEnum.OPENID_CONNECT,
       config: {
         clientId: '138d7bf8-c930-4c6e-b928-97d3a4928b01',
@@ -390,32 +648,32 @@ describe('Database entities tests', (): void => {
         issuer: 'https://example.com/app-test',
         redirectUrl: 'app:/callback',
         dangerouslyAllowInsecureHttpRequests: true,
-        clientAuthMethod: 'post' as const,
+        clientAuthMethod: <const>'post',
       },
     }
-    const connectionEntity = connectionEntityFrom(connection)
+    const connectionEntity: ConnectionEntity = connectionEntityFrom(connection)
     await dbConnection.getRepository(ConnectionEntity).save(connectionEntity, {
       transaction: true,
     })
 
-    const fromDb = await dbConnection.getRepository(ConnectionEntity).findOne({
+    const fromDb: ConnectionEntity | null = await dbConnection.getRepository(ConnectionEntity).findOne({
       where: { type: connection.type },
     })
 
     expect(fromDb).toBeDefined()
 
-    const fromDbConfig = await dbConnection.getRepository(OpenIdConfigEntity).findOne({
+    const fromDbConfig: OpenIdConfigEntity | null = await dbConnection.getRepository(OpenIdConfigEntity).findOne({
       where: { id: fromDb?.id },
     })
 
     expect(fromDbConfig).toBeDefined()
     expect(fromDb?.type).toEqual(connection.type)
     expect(fromDb?.config).toBeDefined()
-    expect((fromDb?.config as OpenIdConfigEntity).clientId).toEqual(connection.config.clientId)
+    expect((<OpenIdConfigEntity>fromDb?.config).clientId).toEqual((<NonPersistedOpenIdConfig>connection.config).clientId)
   })
 
   it('Should save connection with didauth config to database', async (): Promise<void> => {
-    const connection = {
+    const connection: NonPersistedConnection = {
       type: ConnectionTypeEnum.SIOPv2,
       config: {
         identifier: {
@@ -429,55 +687,55 @@ describe('Database entities tests', (): void => {
         sessionId: 'https://example.com/did:test:138d7bf8-c930-4c6e-b928-97d3a4928b01',
       },
     }
-    const connectionEntity = connectionEntityFrom(connection)
+    const connectionEntity: ConnectionEntity = connectionEntityFrom(connection)
     await dbConnection.getRepository(ConnectionEntity).save(connectionEntity, {
       transaction: true,
     })
 
-    const fromDb = await dbConnection.getRepository(ConnectionEntity).findOne({
+    const fromDb: ConnectionEntity | null = await dbConnection.getRepository(ConnectionEntity).findOne({
       where: { type: connection.type },
     })
 
     expect(fromDb).toBeDefined()
 
-    const fromDbConfig = await dbConnection.getRepository(DidAuthConfigEntity).findOne({
+    const fromDbConfig: DidAuthConfigEntity | null = await dbConnection.getRepository(DidAuthConfigEntity).findOne({
       where: { id: fromDb?.id },
     })
 
     expect(fromDbConfig).toBeDefined()
     expect(fromDb?.type).toEqual(connection.type)
     expect(fromDb?.config).toBeDefined()
-    expect((fromDb?.config as DidAuthConfigEntity).identifier).toEqual(connection.config.identifier.did)
+    expect((<DidAuthConfigEntity>fromDb?.config).identifier).toEqual((<NonPersistedDidAuthConfig>connection.config).identifier.did)
   })
 
   it('Should save openid config to database', async (): Promise<void> => {
     const clientId = '138d7bf8-c930-4c6e-b928-97d3a4928b01'
-    const config = {
+    const config: NonPersistedOpenIdConfig = {
       clientId,
       clientSecret: '03b3955f-d020-4f2a-8a27-4e452d4e27a0',
       scopes: ['auth'],
       issuer: 'https://example.com/app-test',
       redirectUrl: 'app:/callback',
       dangerouslyAllowInsecureHttpRequests: true,
-      clientAuthMethod: 'post' as const,
+      clientAuthMethod: <const>'post',
     }
 
-    const configEntity = openIdConfigEntityFrom(config)
+    const configEntity: OpenIdConfigEntity = openIdConfigEntityFrom(config)
     await dbConnection.getRepository(OpenIdConfigEntity).save(configEntity, {
       transaction: true,
     })
 
-    const fromDb = await dbConnection.getRepository(OpenIdConfigEntity).findOne({
+    const fromDb: OpenIdConfigEntity | null = await dbConnection.getRepository(OpenIdConfigEntity).findOne({
       where: { clientId: config.clientId },
     })
 
     expect(fromDb).toBeDefined()
-    expect((fromDb as OpenIdConfigEntity).clientId).toEqual(config.clientId)
+    expect((<OpenIdConfigEntity>fromDb).clientId).toEqual(config.clientId)
   })
 
   it('Should save didauth config to database', async (): Promise<void> => {
     const sessionId = 'https://example.com/did:test:138d7bf8-c930-4c6e-b928-97d3a4928b01'
-    const config = {
+    const config: NonPersistedDidAuthConfig = {
       identifier: {
         did: 'did:test:138d7bf8-c930-4c6e-b928-97d3a4928b01',
         provider: 'test_provider',
@@ -489,31 +747,62 @@ describe('Database entities tests', (): void => {
       sessionId,
     }
 
-    const configEntity = didAuthConfigEntityFrom(config)
+    const configEntity: DidAuthConfigEntity = didAuthConfigEntityFrom(config)
     await dbConnection.getRepository(DidAuthConfigEntity).save(configEntity, {
       transaction: true,
     })
 
-    const fromDb = await dbConnection.getRepository(DidAuthConfigEntity).findOne({
+    const fromDb: DidAuthConfigEntity | null = await dbConnection.getRepository(DidAuthConfigEntity).findOne({
       where: { sessionId: config.sessionId },
     })
 
     expect(fromDb).toBeDefined()
-    expect((fromDb as DidAuthConfigEntity).identifier).toEqual(config.identifier.did)
+    expect((<DidAuthConfigEntity>fromDb).identifier).toEqual(config.identifier.did)
   })
 
-  it('Should delete contact and all child relations', async (): Promise<void> => {
-    const contact = {
-      name: 'relation_test_name',
-      alias: 'relation_test_alias',
+  it('Should delete party and all child relations', async (): Promise<void> => {
+    const party1: NonPersistedParty = {
       uri: 'example.com',
+      partyType: {
+        type: PartyTypeEnum.NATURAL_PERSON,
+        tenantId: '0605761c-4113-4ce5-a6b2-9cbae2f9d289',
+        name: 'example_name1',
+      },
+      contact: {
+        firstName: 'example_first_name1',
+        middleName: 'example_middle_name1',
+        lastName: 'example_last_name1',
+        displayName: 'example_display_name1',
+      },
+    }
+
+    const partyEntity1: PartyEntity = partyEntityFrom(party1)
+    const savedParty1: PartyEntity | null = await dbConnection.getRepository(PartyEntity).save(partyEntity1)
+
+    expect(savedParty1).toBeDefined()
+
+    const party2: NonPersistedParty = {
+      uri: 'example.com',
+      partyType: {
+        type: PartyTypeEnum.NATURAL_PERSON,
+        tenantId: '0605761c-4113-4ce5-a6b2-9cbae2f9d288',
+        name: 'example_name2',
+      },
+      contact: {
+        firstName: 'example_first_name2',
+        middleName: 'example_middle_name2',
+        lastName: 'example_last_name2',
+        displayName: 'example_display_name2',
+      },
     }
 
-    const contactEntity: ContactEntity = contactEntityFrom(contact)
-    const savedContact = await dbConnection.getRepository(ContactEntity).save(contactEntity)
+    const partyEntity2: PartyEntity = partyEntityFrom(party2)
+    const savedParty2: PartyEntity | null = await dbConnection.getRepository(PartyEntity).save(partyEntity2)
+
+    expect(savedParty2).toBeDefined()
 
     const correlationId = 'relation_example.com'
-    const identity = {
+    const identity: NonPersistedIdentity = {
       alias: correlationId,
       roles: [IdentityRoleEnum.ISSUER, IdentityRoleEnum.VERIFIER],
       identifier: {
@@ -529,7 +818,7 @@ describe('Database entities tests', (): void => {
           issuer: 'https://example.com/app-test',
           redirectUrl: 'app:/callback',
           dangerouslyAllowInsecureHttpRequests: true,
-          clientAuthMethod: 'post' as const,
+          clientAuthMethod: <const>'post',
         },
       },
       metadata: [
@@ -541,29 +830,42 @@ describe('Database entities tests', (): void => {
     }
 
     const identityEntity: IdentityEntity = identityEntityFrom(identity)
-    identityEntity.contact = savedContact
+    identityEntity.party = savedParty1
+
+    const savedIdentity: IdentityEntity | null = await dbConnection.getRepository(IdentityEntity).save(identityEntity)
+
+    expect(savedIdentity).toBeDefined()
+
+    const relationship: PartyRelationshipEntity = partyRelationshipEntityFrom({
+      leftId: savedParty1.id,
+      rightId: savedParty2.id,
+    })
+
+    const savedRelationship: PartyRelationshipEntity | null = await dbConnection.getRepository(PartyRelationshipEntity).save(relationship, {
+      transaction: true,
+    })
 
-    const savedIdentity = await dbConnection.getRepository(IdentityEntity).save(identityEntity)
+    expect(savedRelationship).toBeDefined()
 
     expect(
-      await dbConnection.getRepository(ContactEntity).findOne({
-        where: { name: contact.name },
+      await dbConnection.getRepository(PartyEntity).findOne({
+        where: { id: savedParty1.id },
       })
     ).toBeDefined()
 
-    await dbConnection.getRepository(ContactEntity).delete({ id: savedContact.id })
+    await dbConnection.getRepository(PartyEntity).delete({ id: savedParty1.id })
 
-    // check contact
+    // check party
     await expect(
-      await dbConnection.getRepository(ContactEntity).findOne({
-        where: { name: contact.name },
+      await dbConnection.getRepository(PartyEntity).findOne({
+        where: { id: savedParty1.id },
       })
     ).toBeNull()
 
     // check identity
     expect(
       await dbConnection.getRepository(IdentityEntity).findOne({
-        where: { alias: correlationId },
+        where: { id: savedParty1.id },
       })
     ).toBeNull()
 
@@ -594,20 +896,52 @@ describe('Database entities tests', (): void => {
         where: { id: savedIdentity.metadata![0].id },
       })
     ).toBeNull()
+
+    // check contact
+    expect(
+      await dbConnection.getRepository(BaseContactEntity).findOne({
+        where: { id: savedParty1.contact.id },
+      })
+    ).toBeNull()
+
+    // check party type
+    expect(
+      await dbConnection.getRepository(PartyTypeEntity).findOne({
+        where: { id: savedParty1.partyType.id },
+      })
+    ).toBeDefined()
+
+    // check relation
+    expect(
+      await dbConnection.getRepository(PartyRelationshipEntity).findOne({
+        where: { id: savedRelationship.id },
+      })
+    ).toBeNull()
   })
 
   it('Should delete identity and all child relations', async (): Promise<void> => {
-    const contact = {
-      name: 'relation_test_name',
-      alias: 'relation_test_alias',
+    const party: NonPersistedParty = {
       uri: 'example.com',
+      partyType: {
+        type: PartyTypeEnum.NATURAL_PERSON,
+        tenantId: '0605761c-4113-4ce5-a6b2-9cbae2f9d289',
+        name: 'example_name',
+      },
+      contact: {
+        firstName: 'example_first_name',
+        middleName: 'example_middle_name',
+        lastName: 'example_last_name',
+        displayName: 'example_display_name',
+      },
     }
 
-    const contactEntity: ContactEntity = contactEntityFrom(contact)
-    const savedContact = await dbConnection.getRepository(ContactEntity).save(contactEntity)
+    const partyEntity: PartyEntity = partyEntityFrom(party)
+    const savedParty: PartyEntity | null = await dbConnection.getRepository(PartyEntity).save(partyEntity)
+
+    expect(savedParty).toBeDefined()
 
     const correlationId = 'relation_example.com'
-    const identity = {
+    const identity: NonPersistedIdentity = {
       alias: correlationId,
       roles: [IdentityRoleEnum.ISSUER, IdentityRoleEnum.VERIFIER],
       identifier: {
@@ -637,13 +971,13 @@ describe('Database entities tests', (): void => {
     }
 
     const identityEntity: IdentityEntity = identityEntityFrom(identity)
-    identityEntity.contact = savedContact
+    identityEntity.party = savedParty
 
-    const savedIdentity = await dbConnection.getRepository(IdentityEntity).save(identityEntity)
+    const savedIdentity: IdentityEntity | null = await dbConnection.getRepository(IdentityEntity).save(identityEntity)
 
     expect(
-      await dbConnection.getRepository(ContactEntity).findOne({
-        where: { name: contact.name },
+      await dbConnection.getRepository(PartyEntity).findOne({
+        where: { id: savedParty.id },
       })
     ).toBeDefined()
 
@@ -685,18 +1019,29 @@ describe('Database entities tests', (): void => {
     ).toBeNull()
   })
 
-  it('Should not delete contact when deleting identity', async (): Promise<void> => {
-    const contact = {
-      name: 'relation_test_name',
-      alias: 'relation_test_alias',
+  it('Should not delete party when deleting identity', async (): Promise<void> => {
+    const party: NonPersistedParty = {
       uri: 'example.com',
+      partyType: {
+        type: PartyTypeEnum.NATURAL_PERSON,
+        tenantId: '0605761c-4113-4ce5-a6b2-9cbae2f9d289',
+        name: 'example_name',
+      },
+      contact: {
+        firstName: 'example_first_name',
+        middleName: 'example_middle_name',
+        lastName: 'example_last_name',
+        displayName: 'example_display_name',
+      },
     }
 
-    const contactEntity: ContactEntity = contactEntityFrom(contact)
-    const savedContact = await dbConnection.getRepository(ContactEntity).save(contactEntity)
+    const partyEntity: PartyEntity = partyEntityFrom(party)
+    const savedParty: PartyEntity | null = await dbConnection.getRepository(PartyEntity).save(partyEntity)
+
+    expect(savedParty).toBeDefined()
 
     const correlationId = 'relation_example.com'
-    const identity = {
+    const identity: NonPersistedIdentity = {
       alias: correlationId,
       roles: [IdentityRoleEnum.ISSUER, IdentityRoleEnum.VERIFIER],
       identifier: {
@@ -726,9 +1071,11 @@ describe('Database entities tests', (): void => {
     }
 
     const identityEntity: IdentityEntity = identityEntityFrom(identity)
-    identityEntity.contact = savedContact
+    identityEntity.party = savedParty
 
-    const savedIdentity = await dbConnection.getRepository(IdentityEntity).save(identityEntity)
+    const savedIdentity: IdentityEntity | null = await dbConnection.getRepository(IdentityEntity).save(identityEntity)
+
+    expect(savedIdentity).toBeDefined()
 
     await dbConnection.getRepository(IdentityEntity).delete({ id: savedIdentity.id })
 
@@ -739,55 +1086,83 @@ describe('Database entities tests', (): void => {
       })
     ).toBeNull()
 
-    // check contact
+    // check party
     expect(
-      await dbConnection.getRepository(ContactEntity).findOne({
-        where: { name: contact.name },
+      await dbConnection.getRepository(PartyEntity).findOne({
+        where: { id: savedParty.id },
       })
     ).toBeDefined()
   })
 
-  it('Should set creation date when saving contact', async (): Promise<void> => {
-    const contact = {
-      name: 'test_name',
-      alias: 'test_alias',
+  it('Should set creation date when saving party', async (): Promise<void> => {
+    const party: NonPersistedParty = {
       uri: 'example.com',
+      partyType: {
+        type: PartyTypeEnum.NATURAL_PERSON,
+        tenantId: '0605761c-4113-4ce5-a6b2-9cbae2f9d289',
+        name: 'example_name',
+      },
+      contact: {
+        firstName: 'example_first_name',
+        middleName: 'example_middle_name',
+        lastName: 'example_last_name',
+        displayName: 'example_display_name',
+      },
     }
 
-    const contactEntity: ContactEntity = contactEntityFrom(contact)
-    await dbConnection.getRepository(ContactEntity).save(contactEntity)
+    const partyEntity: PartyEntity = partyEntityFrom(party)
+    const savedParty: PartyEntity | null = await dbConnection.getRepository(PartyEntity).save(partyEntity)
 
-    const fromDb = await dbConnection.getRepository(ContactEntity).findOne({
-      where: { name: contact.name },
+    const fromDb: PartyEntity | null = await dbConnection.getRepository(PartyEntity).findOne({
+      where: { id: savedParty.id },
     })
 
     expect(fromDb).toBeDefined()
     expect(fromDb?.createdAt).toBeDefined()
   })
 
-  it('Should not update creation date when updating contact', async (): Promise<void> => {
-    const contact = {
-      name: 'test_name',
-      alias: 'test_alias',
+  it('Should not update creation date when updating party', async (): Promise<void> => {
+    const party: NonPersistedParty = {
       uri: 'example.com',
+      partyType: {
+        type: PartyTypeEnum.NATURAL_PERSON,
+        tenantId: '0605761c-4113-4ce5-a6b2-9cbae2f9d289',
+        name: 'example_name',
+      },
+      contact: {
+        firstName: 'example_first_name',
+        middleName: 'example_middle_name',
+        lastName: 'example_last_name',
+        displayName: 'example_display_name',
+      },
     }
 
-    const contactEntity: ContactEntity = contactEntityFrom(contact)
-    const savedContact = await dbConnection.getRepository(ContactEntity).save(contactEntity)
-    const newContactName = 'new_name'
-    await dbConnection.getRepository(ContactEntity).save({ ...savedContact, name: newContactName })
+    const partyEntity: PartyEntity = partyEntityFrom(party)
+    const savedParty: PartyEntity | null = await dbConnection.getRepository(PartyEntity).save(partyEntity)
+
+    expect(savedParty).toBeDefined()
+
+    const newContactFirstName = 'new_first_name'
+    await dbConnection.getRepository(PartyEntity).save({
+      ...savedParty,
+      contact: {
+        ...savedParty.contact,
+        firstName: newContactFirstName,
+      },
+    })
 
-    const fromDb = await dbConnection.getRepository(ContactEntity).findOne({
-      where: { id: savedContact.id },
+    const fromDb: PartyEntity | null = await dbConnection.getRepository(PartyEntity).findOne({
+      where: { id: savedParty.id },
     })
 
     expect(fromDb).toBeDefined()
-    expect(fromDb?.createdAt).toEqual(savedContact?.createdAt)
+    expect((<NaturalPersonEntity>fromDb?.contact).firstName).toEqual(newContactFirstName)
+    expect(fromDb?.createdAt).toEqual(savedParty?.createdAt)
   })
 
   it('Should set creation date when saving identity', async (): Promise<void> => {
     const correlationId = 'example_did'
-    const identity = {
+    const identity: NonPersistedIdentity = {
       alias: correlationId,
       roles: [IdentityRoleEnum.ISSUER, IdentityRoleEnum.VERIFIER],
       identifier: {
@@ -799,7 +1174,7 @@ describe('Database entities tests', (): void => {
     const identityEntity: IdentityEntity = identityEntityFrom(identity)
     await dbConnection.getRepository(IdentityEntity).save(identityEntity)
 
-    const fromDb = await dbConnection.getRepository(IdentityEntity).findOne({
+    const fromDb: IdentityEntity | null = await dbConnection.getRepository(IdentityEntity).findOne({
       where: {
         identifier: {
           correlationId,
@@ -813,7 +1188,7 @@ describe('Database entities tests', (): void => {
 
   it('Should not update creation date when saving identity', async (): Promise<void> => {
     const correlationId = 'example_did'
-    const identity = {
+    const identity: NonPersistedIdentity = {
       alias: correlationId,
       roles: [IdentityRoleEnum.ISSUER, IdentityRoleEnum.VERIFIER],
       identifier: {
@@ -823,13 +1198,13 @@ describe('Database entities tests', (): void => {
     }
 
     const identityEntity: IdentityEntity = identityEntityFrom(identity)
-    const savedIdentity = await dbConnection.getRepository(IdentityEntity).save(identityEntity)
+    const savedIdentity: IdentityEntity | null = await dbConnection.getRepository(IdentityEntity).save(identityEntity)
     const newCorrelationId = 'new_example_did'
     await dbConnection
       .getRepository(IdentityEntity)
       .save({ ...savedIdentity, identifier: { ...savedIdentity.identifier, correlationId: newCorrelationId } })
 
-    const fromDb = await dbConnection.getRepository(IdentityEntity).findOne({
+    const fromDb: IdentityEntity | null = await dbConnection.getRepository(IdentityEntity).findOne({
       where: {
         identifier: {
           correlationId: newCorrelationId,
@@ -841,51 +1216,116 @@ describe('Database entities tests', (): void => {
     expect(fromDb?.createdAt).toEqual(savedIdentity?.createdAt)
   })
 
-  it('Should set last updated date when saving contact', async (): Promise<void> => {
-    const contact = {
-      name: 'test_name',
-      alias: 'test_alias',
+  it('Should set last updated date when saving party', async (): Promise<void> => {
+    const party: NonPersistedParty = {
       uri: 'example.com',
+      partyType: {
+        type: PartyTypeEnum.NATURAL_PERSON,
+        tenantId: '0605761c-4113-4ce5-a6b2-9cbae2f9d289',
+        name: 'example_name',
+      },
+      contact: {
+        firstName: 'example_first_name',
+        middleName: 'example_middle_name',
+        lastName: 'example_last_name',
+        displayName: 'example_display_name',
+      },
     }
 
-    const contactEntity: ContactEntity = contactEntityFrom(contact)
-    await dbConnection.getRepository(ContactEntity).save(contactEntity)
+    const partyEntity: PartyEntity = partyEntityFrom(party)
+    const savedParty: PartyEntity | null = await dbConnection.getRepository(PartyEntity).save(partyEntity)
 
-    const fromDb = await dbConnection.getRepository(ContactEntity).findOne({
-      where: { name: contact.name },
+    const fromDb: PartyEntity | null = await dbConnection.getRepository(PartyEntity).findOne({
+      where: { id: savedParty.id },
     })
 
     expect(fromDb).toBeDefined()
     expect(fromDb?.lastUpdatedAt).toBeDefined()
   })
 
-  it('Should update last updated date when updating contact', async (): Promise<void> => {
-    const contact = {
-      name: 'test_name',
-      alias: 'test_alias',
+  it('Should update last updated date when updating party', async (): Promise<void> => {
+    const party: NonPersistedParty = {
       uri: 'example.com',
+      partyType: {
+        type: PartyTypeEnum.NATURAL_PERSON,
+        tenantId: '0605761c-4113-4ce5-a6b2-9cbae2f9d289',
+        name: 'example_name',
+      },
+      contact: {
+        firstName: 'example_first_name',
+        middleName: 'example_middle_name',
+        lastName: 'example_last_name',
+        displayName: 'example_display_name',
+      },
     }
 
-    const contactEntity: ContactEntity = contactEntityFrom(contact)
-    const savedContact = await dbConnection.getRepository(ContactEntity).save(contactEntity)
+    const partyEntity: PartyEntity = partyEntityFrom(party)
+    const savedParty: PartyEntity | null = await dbConnection.getRepository(PartyEntity).save(partyEntity)
+    expect(savedParty).toBeDefined()
 
     // waiting here to get a different timestamp
     await new Promise((resolve) => setTimeout(resolve, 2000))
 
-    const newContactName = 'new_name'
-    await dbConnection.getRepository(ContactEntity).save({ ...savedContact, name: newContactName })
+    const newContactFirstName = 'new_first_name'
+    await dbConnection.getRepository(PartyEntity).save({
+      ...savedParty,
+      // FIXME there is still an issue when updating nested objects, the parent does not update
+      // https://github.com/typeorm/typeorm/issues/5378
+      uri: 'new uri', // TODO remove this to trigger the bug
+      contact: {
+        ...savedParty.contact,
+        firstName: newContactFirstName,
+      },
+    })
+
+    const fromDb: PartyEntity | null = await dbConnection.getRepository(PartyEntity).findOne({
+      where: { id: savedParty.id },
+    })
+
+    expect(fromDb).toBeDefined()
+    expect((<NaturalPersonEntity>fromDb?.contact).firstName).toEqual(newContactFirstName)
+    expect(fromDb?.lastUpdatedAt).not.toEqual(savedParty?.lastUpdatedAt)
+  })
+
+  it('Should set last updated date when saving party type', async (): Promise<void> => {
+    const partyType: NonPersistedPartyType = {
+      type: PartyTypeEnum.NATURAL_PERSON,
+      tenantId: '0605761c-4113-4ce5-a6b2-9cbae2f9d289',
+      name: 'example_name',
+    }
+
+    const partyTypeEntity: PartyTypeEntity = partyTypeEntityFrom(partyType)
+    const savedPartyType: PartyTypeEntity | null = await dbConnection.getRepository(PartyTypeEntity).save(partyTypeEntity)
+
+    const fromDb: PartyTypeEntity | null = await dbConnection.getRepository(PartyTypeEntity).findOne({
+      where: { id: savedPartyType.id },
+    })
+
+    expect(fromDb).toBeDefined()
+    expect(fromDb?.lastUpdatedAt).toBeDefined()
+  })
+
+  it('Should set last creation date when saving party type', async (): Promise<void> => {
+    const partyType: NonPersistedPartyType = {
+      type: PartyTypeEnum.NATURAL_PERSON,
+      tenantId: '0605761c-4113-4ce5-a6b2-9cbae2f9d289',
+      name: 'example_name',
+    }
+
+    const partyTypeEntity: PartyTypeEntity = partyTypeEntityFrom(partyType)
+    const savedPartyType: PartyTypeEntity | null = await dbConnection.getRepository(PartyTypeEntity).save(partyTypeEntity)
 
-    const fromDb = await dbConnection.getRepository(ContactEntity).findOne({
-      where: { id: savedContact.id },
+    const fromDb: PartyTypeEntity | null = await dbConnection.getRepository(PartyTypeEntity).findOne({
+      where: { id: savedPartyType.id },
     })
 
     expect(fromDb).toBeDefined()
-    expect(fromDb?.lastUpdatedAt).not.toEqual(savedContact?.lastUpdatedAt)
+    expect(fromDb?.createdAt).toBeDefined()
   })
 
   it('Should set last updated date when saving identity', async (): Promise<void> => {
     const correlationId = 'example_did'
-    const identity = {
+    const identity: NonPersistedIdentity = {
       alias: correlationId,
       roles: [IdentityRoleEnum.ISSUER, IdentityRoleEnum.VERIFIER],
       identifier: {
@@ -897,7 +1337,7 @@ describe('Database entities tests', (): void => {
     const identityEntity: IdentityEntity = identityEntityFrom(identity)
     await dbConnection.getRepository(IdentityEntity).save(identityEntity)
 
-    const fromDb = await dbConnection.getRepository(IdentityEntity).findOne({
+    const fromDb: IdentityEntity | null = await dbConnection.getRepository(IdentityEntity).findOne({
       where: {
         identifier: {
           correlationId,
@@ -908,4 +1348,826 @@ describe('Database entities tests', (): void => {
     expect(fromDb).toBeDefined()
     expect(fromDb?.lastUpdatedAt).toBeDefined()
   })
+
+  it('Should enforce unique type and tenant id combination when saving party type', async (): Promise<void> => {
+    const tenantId = 'non_unique_value'
+    const name = 'non_unique_value'
+    const partyType1: NonPersistedPartyType = {
+      type: PartyTypeEnum.NATURAL_PERSON,
+      tenantId,
+      name,
+    }
+
+    const partyTypeEntity1: PartyTypeEntity = partyTypeEntityFrom(partyType1)
+    const savedPartyType1: PartyTypeEntity | null = await dbConnection.getRepository(PartyTypeEntity).save(partyTypeEntity1)
+
+    expect(savedPartyType1).toBeDefined()
+
+    const partyType2: NonPersistedPartyType = {
+      type: PartyTypeEnum.NATURAL_PERSON,
+      tenantId,
+      name,
+    }
+
+    const partyTypeEntity2: PartyTypeEntity = partyTypeEntityFrom(partyType2)
+    await expect(dbConnection.getRepository(PartyTypeEntity).save(partyTypeEntity2)).rejects.toThrowError(
+      'SQLITE_CONSTRAINT: UNIQUE constraint failed: PartyType.type, PartyType.tenant_id'
+    )
+  })
+
+  it('Should enforce unique name when saving party type', async (): Promise<void> => {
+    const name = 'non_unique_value'
+    const partyType1: NonPersistedPartyType = {
+      type: PartyTypeEnum.NATURAL_PERSON,
+      tenantId: '0605761c-4113-4ce5-a6b2-9cbae2f9d289',
+      name,
+    }
+
+    const partyTypeEntity1: PartyTypeEntity = partyTypeEntityFrom(partyType1)
+    const savedPartyType1: PartyTypeEntity | null = await dbConnection.getRepository(PartyTypeEntity).save(partyTypeEntity1)
+
+    expect(savedPartyType1).toBeDefined()
+
+    const partyType2: NonPersistedPartyType = {
+      type: PartyTypeEnum.NATURAL_PERSON,
+      tenantId: '0605761c-4113-4ce5-a6b2-9cbae2f9d288',
+      name,
+    }
+
+    const partyTypeEntity2: PartyTypeEntity = partyTypeEntityFrom(partyType2)
+    await expect(dbConnection.getRepository(PartyTypeEntity).save(partyTypeEntity2)).rejects.toThrowError(
+      'SQLITE_CONSTRAINT: UNIQUE constraint failed: PartyType.name'
+    )
+  })
+
+  it('Should enforce unique legal name when saving organization', async (): Promise<void> => {
+    const legalName = 'non_unique_value'
+    const organization1: NonPersistedOrganization = {
+      legalName,
+      displayName: 'example_display_name',
+    }
+
+    const organizationEntity1: OrganizationEntity = organizationEntityFrom(organization1)
+    const savedOrganization1: OrganizationEntity | null = await dbConnection.getRepository(OrganizationEntity).save(organizationEntity1, {
+      transaction: true,
+    })
+
+    expect(savedOrganization1).toBeDefined()
+
+    const organization2: NonPersistedOrganization = {
+      legalName,
+      displayName: 'example_display_name',
+    }
+
+    const organizationEntity2: OrganizationEntity = organizationEntityFrom(organization2)
+    await expect(dbConnection.getRepository(OrganizationEntity).save(organizationEntity2)).rejects.toThrowError(
+      'SQLITE_CONSTRAINT: UNIQUE constraint failed: BaseContact.legal_name'
+    )
+  })
+
+  it('Should enforce unique legal name when saving organization', async (): Promise<void> => {
+    const legalName = 'example_legal_name'
+    const organization1: NonPersistedOrganization = {
+      legalName,
+      displayName: 'example_display_name',
+    }
+
+    const organizationEntity1: OrganizationEntity = organizationEntityFrom(organization1)
+    const savedOrganization1: OrganizationEntity | null = await dbConnection.getRepository(OrganizationEntity).save(organizationEntity1, {
+      transaction: true,
+    })
+
+    expect(savedOrganization1).toBeDefined()
+
+    const organization2: NonPersistedOrganization = {
+      legalName,
+      displayName: 'example_display_name',
+    }
+
+    const organizationEntity2: OrganizationEntity = organizationEntityFrom(organization2)
+    await expect(dbConnection.getRepository(OrganizationEntity).save(organizationEntity2)).rejects.toThrowError(
+      'SQLITE_CONSTRAINT: UNIQUE constraint failed: BaseContact.legal_name'
+    )
+  })
+
+  it('Should save party relationship to database', async (): Promise<void> => {
+    const party1: NonPersistedParty = {
+      uri: 'example1.com',
+      partyType: {
+        type: PartyTypeEnum.NATURAL_PERSON,
+        tenantId: '0605761c-4113-4ce5-a6b2-9cbae2f9d289',
+        name: 'example_name1',
+      },
+      contact: {
+        firstName: 'example_first_name1',
+        middleName: 'example_middle_name1',
+        lastName: 'example_last_name1',
+        displayName: 'example_display_name1',
+      },
+    }
+
+    const partyEntity1: PartyEntity = partyEntityFrom(party1)
+    const savedParty1: PartyEntity = await dbConnection.getRepository(PartyEntity).save(partyEntity1, {
+      transaction: true,
+    })
+
+    expect(savedParty1).toBeDefined()
+
+    const party2: NonPersistedParty = {
+      uri: 'example2.com',
+      partyType: {
+        type: PartyTypeEnum.NATURAL_PERSON,
+        tenantId: '0605761c-4113-4ce5-a6b2-9cbae2f9d288',
+        name: 'example_name2',
+      },
+      contact: {
+        firstName: 'example_first_name2',
+        middleName: 'example_middle_name2',
+        lastName: 'example_last_name2',
+        displayName: 'example_display_name2',
+      },
+    }
+
+    const partyEntity2: PartyEntity = partyEntityFrom(party2)
+    const savedParty2: PartyEntity = await dbConnection.getRepository(PartyEntity).save(partyEntity2, {
+      transaction: true,
+    })
+
+    expect(savedParty2).toBeDefined()
+
+    const relationship: PartyRelationshipEntity = partyRelationshipEntityFrom({
+      leftId: savedParty1.id,
+      rightId: savedParty2.id,
+    })
+
+    await dbConnection.getRepository(PartyRelationshipEntity).save(relationship, {
+      transaction: true,
+    })
+
+    // TODO check the relation field
+    const fromDb: PartyEntity | null = await dbConnection.getRepository(PartyEntity).findOne({
+      where: { id: partyEntity1.id },
+    })
+
+    expect(fromDb).toBeDefined()
+  })
+
+  it('Should set last updated date when saving party relationship', async (): Promise<void> => {
+    const party1: NonPersistedParty = {
+      uri: 'example1.com',
+      partyType: {
+        type: PartyTypeEnum.NATURAL_PERSON,
+        tenantId: '0605761c-4113-4ce5-a6b2-9cbae2f9d289',
+        name: 'example_name1',
+      },
+      contact: {
+        firstName: 'example_first_name1',
+        middleName: 'example_middle_name1',
+        lastName: 'example_last_name1',
+        displayName: 'example_display_name1',
+      },
+    }
+
+    const partyEntity1: PartyEntity = partyEntityFrom(party1)
+    const savedParty1: PartyEntity = await dbConnection.getRepository(PartyEntity).save(partyEntity1, {
+      transaction: true,
+    })
+
+    const party2: NonPersistedParty = {
+      uri: 'example2.com',
+      partyType: {
+        type: PartyTypeEnum.NATURAL_PERSON,
+        tenantId: '0605761c-4113-4ce5-a6b2-9cbae2f9d288',
+        name: 'example_name2',
+      },
+      contact: {
+        firstName: 'example_first_name2',
+        middleName: 'example_middle_name2',
+        lastName: 'example_last_name2',
+        displayName: 'example_display_name2',
+      },
+    }
+
+    const partyEntity2: PartyEntity = partyEntityFrom(party2)
+    const savedParty2: PartyEntity = await dbConnection.getRepository(PartyEntity).save(partyEntity2, {
+      transaction: true,
+    })
+
+    const relationship: PartyRelationshipEntity = partyRelationshipEntityFrom({
+      leftId: savedParty1.id,
+      rightId: savedParty2.id,
+    })
+
+    await dbConnection.getRepository(PartyRelationshipEntity).save(relationship, {
+      transaction: true,
+    })
+
+    const fromDb: PartyEntity | null = await dbConnection.getRepository(PartyEntity).findOne({
+      where: { id: partyEntity1.id },
+    })
+
+    expect(fromDb).toBeDefined()
+    expect(fromDb?.lastUpdatedAt).toBeDefined()
+  })
+
+  it('Should set creation date when saving party relationship', async (): Promise<void> => {
+    const party1: NonPersistedParty = {
+      uri: 'example1.com',
+      partyType: {
+        type: PartyTypeEnum.NATURAL_PERSON,
+        tenantId: '0605761c-4113-4ce5-a6b2-9cbae2f9d289',
+        name: 'example_name1',
+      },
+      contact: {
+        firstName: 'example_first_name1',
+        middleName: 'example_middle_name1',
+        lastName: 'example_last_name1',
+        displayName: 'example_display_name1',
+      },
+    }
+
+    const partyEntity1: PartyEntity = partyEntityFrom(party1)
+    const savedParty1: PartyEntity = await dbConnection.getRepository(PartyEntity).save(partyEntity1, {
+      transaction: true,
+    })
+
+    const party2: NonPersistedParty = {
+      uri: 'example2.com',
+      partyType: {
+        type: PartyTypeEnum.NATURAL_PERSON,
+        tenantId: '0605761c-4113-4ce5-a6b2-9cbae2f9d288',
+        name: 'example_name2',
+      },
+      contact: {
+        firstName: 'example_first_name2',
+        middleName: 'example_middle_name2',
+        lastName: 'example_last_name2',
+        displayName: 'example_display_name2',
+      },
+    }
+
+    const partyEntity2: PartyEntity = partyEntityFrom(party2)
+    const savedParty2: PartyEntity = await dbConnection.getRepository(PartyEntity).save(partyEntity2, {
+      transaction: true,
+    })
+
+    const relationship: PartyRelationshipEntity = partyRelationshipEntityFrom({
+      leftId: savedParty1.id,
+      rightId: savedParty2.id,
+    })
+
+    await dbConnection.getRepository(PartyRelationshipEntity).save(relationship, {
+      transaction: true,
+    })
+
+    const fromDb: PartyEntity | null = await dbConnection.getRepository(PartyEntity).findOne({
+      where: { id: partyEntity1.id },
+    })
+
+    expect(fromDb).toBeDefined()
+    expect(fromDb?.createdAt).toBeDefined()
+  })
+
+  it('Should save bidirectional party relationships to database', async (): Promise<void> => {
+    const party1: NonPersistedParty = {
+      uri: 'example1.com',
+      partyType: {
+        type: PartyTypeEnum.NATURAL_PERSON,
+        tenantId: '0605761c-4113-4ce5-a6b2-9cbae2f9d289',
+        name: 'example_name1',
+      },
+      contact: {
+        firstName: 'example_first_name1',
+        middleName: 'example_middle_name1',
+        lastName: 'example_last_name1',
+        displayName: 'example_display_name1',
+      },
+    }
+
+    const partyEntity1: PartyEntity = partyEntityFrom(party1)
+    const savedParty1: PartyEntity = await dbConnection.getRepository(PartyEntity).save(partyEntity1, {
+      transaction: true,
+    })
+
+    expect(savedParty1).toBeDefined()
+
+    const party2: NonPersistedParty = {
+      uri: 'example2.com',
+      partyType: {
+        type: PartyTypeEnum.NATURAL_PERSON,
+        tenantId: '0605761c-4113-4ce5-a6b2-9cbae2f9d288',
+        name: 'example_name2',
+      },
+      contact: {
+        firstName: 'example_first_name2',
+        middleName: 'example_middle_name2',
+        lastName: 'example_last_name2',
+        displayName: 'example_display_name2',
+      },
+    }
+
+    const partyEntity2: PartyEntity = partyEntityFrom(party2)
+    const savedParty2: PartyEntity = await dbConnection.getRepository(PartyEntity).save(partyEntity2, {
+      transaction: true,
+    })
+
+    expect(savedParty2).toBeDefined()
+
+    const relationship1: PartyRelationshipEntity = partyRelationshipEntityFrom({
+      leftId: savedParty1.id,
+      rightId: savedParty2.id,
+    })
+
+    const savedRelationship1: PartyRelationshipEntity | null = await dbConnection.getRepository(PartyRelationshipEntity).save(relationship1, {
+      transaction: true,
+    })
+
+    expect(savedRelationship1).toBeDefined()
+
+    const relationship2: PartyRelationshipEntity = partyRelationshipEntityFrom({
+      leftId: savedParty2.id,
+      rightId: savedParty1.id,
+    })
+
+    const savedRelationship2: PartyRelationshipEntity | null = await dbConnection.getRepository(PartyRelationshipEntity).save(relationship2, {
+      transaction: true,
+    })
+
+    expect(savedRelationship2).toBeDefined()
+
+    const fromDb: PartyRelationshipEntity | null = await dbConnection.getRepository(PartyRelationshipEntity).findOne({
+      where: { id: savedRelationship2.id },
+    })
+
+    expect(fromDb).toBeDefined()
+  })
+
+  it('Should enforce unique owner combination for party relationship', async (): Promise<void> => {
+    const party1: NonPersistedParty = {
+      uri: 'example1.com',
+      partyType: {
+        type: PartyTypeEnum.NATURAL_PERSON,
+        tenantId: '0605761c-4113-4ce5-a6b2-9cbae2f9d289',
+        name: 'example_name1',
+      },
+      contact: {
+        firstName: 'example_first_name1',
+        middleName: 'example_middle_name1',
+        lastName: 'example_last_name1',
+        displayName: 'example_display_name1',
+      },
+    }
+
+    const partyEntity1: PartyEntity = partyEntityFrom(party1)
+    const savedParty1: PartyEntity = await dbConnection.getRepository(PartyEntity).save(partyEntity1, {
+      transaction: true,
+    })
+
+    expect(savedParty1).toBeDefined()
+
+    const party2: NonPersistedParty = {
+      uri: 'example2.com',
+      partyType: {
+        type: PartyTypeEnum.NATURAL_PERSON,
+        tenantId: '0605761c-4113-4ce5-a6b2-9cbae2f9d288',
+        name: 'example_name2',
+      },
+      contact: {
+        firstName: 'example_first_name2',
+        middleName: 'example_middle_name2',
+        lastName: 'example_last_name2',
+        displayName: 'example_display_name2',
+      },
+    }
+
+    const partyEntity2: PartyEntity = partyEntityFrom(party2)
+    const savedParty2: PartyEntity = await dbConnection.getRepository(PartyEntity).save(partyEntity2, {
+      transaction: true,
+    })
+
+    expect(savedParty2).toBeDefined()
+
+    const relationship1: PartyRelationshipEntity = partyRelationshipEntityFrom({
+      leftId: savedParty1.id,
+      rightId: savedParty2.id,
+    })
+
+    const savedRelationship1: PartyRelationshipEntity | null = await dbConnection.getRepository(PartyRelationshipEntity).save(relationship1, {
+      transaction: true,
+    })
+
+    expect(savedRelationship1).toBeDefined()
+
+    const relationship2: PartyRelationshipEntity = partyRelationshipEntityFrom({
+      leftId: savedParty1.id,
+      rightId: savedParty2.id,
+    })
+
+    await expect(dbConnection.getRepository(PartyRelationshipEntity).save(relationship2)).rejects.toThrowError(
+      'SQLITE_CONSTRAINT: UNIQUE constraint failed: PartyRelationship.left_id, PartyRelationship.right_id'
+    )
+  })
+
+  it('Should save party type to database', async (): Promise<void> => {
+    const partyType: NonPersistedPartyType = {
+      type: PartyTypeEnum.NATURAL_PERSON,
+      tenantId: '0605761c-4113-4ce5-a6b2-9cbae2f9d289',
+      name: 'example_name',
+    }
+
+    const partyTypeEntity: PartyTypeEntity = partyTypeEntityFrom(partyType)
+    const savedPartyType: PartyTypeEntity | null = await dbConnection.getRepository(PartyTypeEntity).save(partyTypeEntity)
+
+    const fromDb: PartyTypeEntity | null = await dbConnection.getRepository(PartyTypeEntity).findOne({
+      where: { id: savedPartyType.id },
+    })
+
+    expect(fromDb).toBeDefined()
+  })
+
+  it('Should save person to database', async (): Promise<void> => {
+    const person: NonPersistedNaturalPerson = {
+      firstName: 'example_first_name',
+      lastName: 'lastName2',
+      displayName: 'displayName',
+    }
+
+    const personEntity: NaturalPersonEntity = naturalPersonEntityFrom(person)
+    const savedPerson: NaturalPersonEntity | null = await dbConnection.getRepository(NaturalPersonEntity).save(personEntity, {
+      transaction: true,
+    })
+
+    const fromDb: NaturalPersonEntity | null = await dbConnection.getRepository(NaturalPersonEntity).findOne({
+      where: { id: savedPerson.id },
+    })
+
+    expect(fromDb).toBeDefined()
+  })
+
+  it('Should set last updated date when saving person', async (): Promise<void> => {
+    const person: NonPersistedNaturalPerson = {
+      firstName: 'example_first_name',
+      lastName: 'lastName2',
+      displayName: 'displayName',
+    }
+
+    const personEntity: NaturalPersonEntity = naturalPersonEntityFrom(person)
+    const savedPerson: NaturalPersonEntity | null = await dbConnection.getRepository(NaturalPersonEntity).save(personEntity, {
+      transaction: true,
+    })
+
+    const fromDb: NaturalPersonEntity | null = await dbConnection.getRepository(NaturalPersonEntity).findOne({
+      where: { id: savedPerson.id },
+    })
+
+    expect(fromDb).toBeDefined()
+    expect(fromDb?.lastUpdatedAt).toBeDefined()
+  })
+
+  it('Should set creation date when saving person', async (): Promise<void> => {
+    const person: NonPersistedNaturalPerson = {
+      firstName: 'example_first_name',
+      lastName: 'lastName2',
+      displayName: 'displayName',
+    }
+
+    const personEntity: NaturalPersonEntity = naturalPersonEntityFrom(person)
+    const savedPerson: NaturalPersonEntity | null = await dbConnection.getRepository(NaturalPersonEntity).save(personEntity, {
+      transaction: true,
+    })
+
+    const fromDb: NaturalPersonEntity | null = await dbConnection.getRepository(NaturalPersonEntity).findOne({
+      where: { id: savedPerson.id },
+    })
+
+    expect(fromDb).toBeDefined()
+    expect(fromDb?.createdAt).toBeDefined()
+  })
+
+  it('Should save organization to database', async (): Promise<void> => {
+    const organization: NonPersistedOrganization = {
+      legalName: 'example_legal_name',
+      displayName: 'example_display_name',
+    }
+
+    const organizationEntity: OrganizationEntity = organizationEntityFrom(organization)
+    const savedOrganization: OrganizationEntity | null = await dbConnection.getRepository(OrganizationEntity).save(organizationEntity, {
+      transaction: true,
+    })
+
+    const fromDb: OrganizationEntity | null = await dbConnection.getRepository(OrganizationEntity).findOne({
+      where: { id: savedOrganization.id },
+    })
+
+    expect(fromDb).toBeDefined()
+  })
+
+  it('Should set last updated date when saving organization', async (): Promise<void> => {
+    const organization: NonPersistedOrganization = {
+      legalName: 'example_legal_name',
+      displayName: 'example_display_name',
+    }
+
+    const organizationEntity: OrganizationEntity = organizationEntityFrom(organization)
+    const savedOrganization: OrganizationEntity | null = await dbConnection.getRepository(OrganizationEntity).save(organizationEntity, {
+      transaction: true,
+    })
+
+    const fromDb: OrganizationEntity | null = await dbConnection.getRepository(OrganizationEntity).findOne({
+      where: { id: savedOrganization.id },
+    })
+
+    expect(fromDb).toBeDefined()
+    expect(fromDb?.lastUpdatedAt).toBeDefined()
+  })
+
+  it('Should set creation date when saving organization', async (): Promise<void> => {
+    const organization: NonPersistedOrganization = {
+      legalName: 'example_legal_name',
+      displayName: 'example_display_name',
+    }
+
+    const organizationEntity: OrganizationEntity = organizationEntityFrom(organization)
+    const savedOrganization: OrganizationEntity | null = await dbConnection.getRepository(OrganizationEntity).save(organizationEntity, {
+      transaction: true,
+    })
+
+    const fromDb: OrganizationEntity | null = await dbConnection.getRepository(OrganizationEntity).findOne({
+      where: { id: savedOrganization.id },
+    })
+
+    expect(fromDb).toBeDefined()
+    expect(fromDb?.createdAt).toBeDefined()
+  })
+
+  it('Should get party based on person information', async (): Promise<void> => {
+    const firstName = 'example_first_name'
+    const party: NonPersistedParty = {
+      uri: 'example.com',
+      partyType: {
+        type: PartyTypeEnum.NATURAL_PERSON,
+        tenantId: '0605761c-4113-4ce5-a6b2-9cbae2f9d289',
+        name: 'example_name',
+      },
+      contact: {
+        firstName,
+        middleName: 'example_middle_name',
+        lastName: 'example_last_name',
+        displayName: 'example_display_name',
+      },
+    }
+
+    const partyEntity: PartyEntity = partyEntityFrom(party)
+    await dbConnection.getRepository(PartyEntity).save(partyEntity, {
+      transaction: true,
+    })
+
+    const fromDb: PartyEntity | null = await dbConnection.getRepository(PartyEntity).findOne({
+      where: {
+        contact: {
+          firstName,
+        } as FindOptionsWhere<BaseContactEntity>, //NaturalPersonEntity | OrganizationEntity
+      },
+    })
+
+    expect(fromDb).toBeDefined()
+  })
+
+  it('Should get party based on organization information', async (): Promise<void> => {
+    const legalName = 'example_legal_name'
+    const party: NonPersistedParty = {
+      uri: 'example.com',
+      partyType: {
+        type: PartyTypeEnum.ORGANIZATION,
+        tenantId: '0605761c-4113-4ce5-a6b2-9cbae2f9d289',
+        name: 'example_name',
+      },
+      contact: {
+        legalName,
+        displayName: 'example_display_name',
+      },
+    }
+
+    const partyEntity: PartyEntity = partyEntityFrom(party)
+    await dbConnection.getRepository(PartyEntity).save(partyEntity, {
+      transaction: true,
+    })
+
+    const fromDb: PartyEntity | null = await dbConnection.getRepository(PartyEntity).findOne({
+      where: {
+        contact: {
+          legalName,
+        } as FindOptionsWhere<BaseContactEntity>, //NaturalPersonEntity | OrganizationEntity
+      },
+    })
+
+    expect(fromDb).toBeDefined()
+  })
+
+  it("Should enforce unique party id's for relationship sides", async (): Promise<void> => {
+    const party: NonPersistedParty = {
+      uri: 'example.com',
+      partyType: {
+        type: PartyTypeEnum.NATURAL_PERSON,
+        tenantId: '0605761c-4113-4ce5-a6b2-9cbae2f9d289',
+        name: 'example_name',
+      },
+      contact: {
+        firstName: 'example_first_name',
+        middleName: 'example_middle_name',
+        lastName: 'example_last_name',
+        displayName: 'example_display_name',
+      },
+    }
+
+    const partyEntity: PartyEntity = partyEntityFrom(party)
+    const savedParty: PartyEntity = await dbConnection.getRepository(PartyEntity).save(partyEntity, {
+      transaction: true,
+    })
+
+    expect(savedParty).toBeDefined()
+
+    const relationship: PartyRelationshipEntity = partyRelationshipEntityFrom({
+      leftId: savedParty.id,
+      rightId: savedParty.id,
+    })
+
+    await expect(dbConnection.getRepository(PartyRelationshipEntity).save(relationship)).rejects.toThrowError(
+      'Cannot use the same id for both sides of the relationship'
+    )
+  })
+
+  it('Should delete party relationship', async (): Promise<void> => {
+    const party1: NonPersistedParty = {
+      uri: 'example1.com',
+      partyType: {
+        type: PartyTypeEnum.NATURAL_PERSON,
+        tenantId: '0605761c-4113-4ce5-a6b2-9cbae2f9d289',
+        name: 'example_name1',
+      },
+      contact: {
+        firstName: 'example_first_name1',
+        middleName: 'example_middle_name1',
+        lastName: 'example_last_name1',
+        displayName: 'example_display_name1',
+      },
+    }
+
+    const partyEntity1: PartyEntity = partyEntityFrom(party1)
+    const savedParty1: PartyEntity = await dbConnection.getRepository(PartyEntity).save(partyEntity1, {
+      transaction: true,
+    })
+
+    expect(savedParty1).toBeDefined()
+
+    const party2: NonPersistedParty = {
+      uri: 'example2.com',
+      partyType: {
+        type: PartyTypeEnum.NATURAL_PERSON,
+        tenantId: '0605761c-4113-4ce5-a6b2-9cbae2f9d288',
+        name: 'example_name2',
+      },
+      contact: {
+        firstName: 'example_first_name2',
+        middleName: 'example_middle_name2',
+        lastName: 'example_last_name2',
+        displayName: 'example_display_name2',
+      },
+    }
+
+    const partyEntity2: PartyEntity = partyEntityFrom(party2)
+    const savedParty2: PartyEntity = await dbConnection.getRepository(PartyEntity).save(partyEntity2, {
+      transaction: true,
+    })
+
+    expect(savedParty2).toBeDefined()
+
+    const relationship: PartyRelationshipEntity = partyRelationshipEntityFrom({
+      leftId: savedParty1.id,
+      rightId: savedParty2.id,
+    })
+
+    const savedRelationship: PartyRelationshipEntity | null = await dbConnection.getRepository(PartyRelationshipEntity).save(relationship, {
+      transaction: true,
+    })
+
+    expect(savedRelationship).toBeDefined()
+
+    await dbConnection.getRepository(PartyRelationshipEntity).delete({ id: savedRelationship.id })
+
+    await expect(
+      await dbConnection.getRepository(PartyRelationshipEntity).findOne({
+        where: { id: savedRelationship.id },
+      })
+    ).toBeNull()
+  })
+
+  it('Should delete party type', async (): Promise<void> => {
+    const partyType: NonPersistedPartyType = {
+      type: PartyTypeEnum.NATURAL_PERSON,
+      tenantId: '0605761c-4113-4ce5-a6b2-9cbae2f9d289',
+      name: 'example_name',
+    }
+
+    const partyTypeEntity: PartyTypeEntity = partyTypeEntityFrom(partyType)
+    const savedPartyType: PartyTypeEntity | null = await dbConnection.getRepository(PartyTypeEntity).save(partyTypeEntity)
+
+    expect(savedPartyType).toBeDefined()
+
+    await dbConnection.getRepository(PartyTypeEntity).delete({ id: savedPartyType.id })
+
+    await expect(
+      await dbConnection.getRepository(PartyTypeEntity).findOne({
+        where: { id: savedPartyType.id },
+      })
+    ).toBeNull()
+  })
+
+  it('Should not be able to remove party type when used by parties', async (): Promise<void> => {
+    const party: NonPersistedParty = {
+      uri: 'example.com',
+      partyType: {
+        type: PartyTypeEnum.NATURAL_PERSON,
+        tenantId: '0605761c-4113-4ce5-a6b2-9cbae2f9d289',
+        name: 'example_name',
+      },
+      contact: {
+        firstName: 'example_first_name',
+        middleName: 'example_middle_name',
+        lastName: 'example_last_name',
+        displayName: 'example_display_name',
+      },
+    }
+
+    const partyEntity: PartyEntity = partyEntityFrom(party)
+    const savedParty: PartyEntity | null = await dbConnection.getRepository(PartyEntity).save(partyEntity, {
+      transaction: true,
+    })
+
+    expect(savedParty).toBeDefined()
+
+    await expect(dbConnection.getRepository(PartyTypeEntity).delete({ id: savedParty.partyType.id })).rejects.toThrowError(
+      'FOREIGN KEY constraint failed'
+    )
+  })
+
+  it('Should save party with existing party type', async (): Promise<void> => {
+    const partyType: NonPersistedPartyType = {
+      type: PartyTypeEnum.NATURAL_PERSON,
+      tenantId: '0605761c-4113-4ce5-a6b2-9cbae2f9d289',
+      name: 'example_name',
+    }
+
+    const partyTypeEntity: PartyTypeEntity = partyTypeEntityFrom(partyType)
+    const savedPartyType: PartyTypeEntity | null = await dbConnection.getRepository(PartyTypeEntity).save(partyTypeEntity)
+
+    const party: NonPersistedParty = {
+      uri: 'example.com',
+      partyType: savedPartyType,
+      contact: {
+        firstName: 'example_first_name',
+        middleName: 'example_middle_name',
+        lastName: 'example_last_name',
+        displayName: 'example_display_name',
+      },
+    }
+
+    const partyEntity: PartyEntity = partyEntityFrom(party)
+    partyEntity.partyType = savedPartyType
+    await dbConnection.getRepository(PartyEntity).save(partyEntity, {
+      transaction: true,
+    })
+
+    const fromDb: PartyEntity | null = await dbConnection.getRepository(PartyEntity).findOne({
+      where: { id: partyEntity.id },
+    })
+
+    expect(fromDb).toBeDefined()
+    expect(fromDb?.partyType).toBeDefined()
+    expect(fromDb?.partyType.id).toEqual(savedPartyType.id)
+    expect(fromDb?.partyType.type).toEqual(savedPartyType.type)
+    expect(fromDb?.partyType.tenantId).toEqual(savedPartyType.tenantId)
+    expect(fromDb?.partyType.name).toEqual(savedPartyType.name)
+  })
+
+  it('Should not update creation date when saving party type', async (): Promise<void> => {
+    const partyType: NonPersistedPartyType = {
+      type: PartyTypeEnum.NATURAL_PERSON,
+      tenantId: '0605761c-4113-4ce5-a6b2-9cbae2f9d289',
+      name: 'example_name',
+    }
+
+    const partyTypeEntity: PartyTypeEntity = partyTypeEntityFrom(partyType)
+    const savedPartyType: PartyTypeEntity | null = await dbConnection.getRepository(PartyTypeEntity).save(partyTypeEntity)
+    await dbConnection.getRepository(PartyTypeEntity).save({ ...savedPartyType, type: PartyTypeEnum.ORGANIZATION })
+
+    const fromDb: PartyTypeEntity | null = await dbConnection.getRepository(PartyTypeEntity).findOne({
+      where: {
+        type: PartyTypeEnum.ORGANIZATION,
+      },
+    })
+
+    expect(fromDb).toBeDefined()
+    expect(fromDb?.createdAt).toEqual(savedPartyType?.createdAt)
+  })
 })