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

package/src/contact/ContactStore.ts

@@ -1,40 +1,62 @@
-import Debug from 'debug'
 import { OrPromise } from '@sphereon/ssi-types'
+import { DataSource, In, Repository } from 'typeorm'
+import Debug from 'debug'
 import { AbstractContactStore } from './AbstractContactStore'
-import {
-  IAddIdentityArgs,
-  IGetIdentityArgs,
-  IGetIdentitiesArgs,
-  IGetContactArgs,
-  IRemoveIdentityArgs,
-  IUpdateIdentityArgs,
-  IGetContactsArgs,
-  IAddContactArgs,
-  IUpdateContactArgs,
-  IRemoveContactArgs,
-  BasicConnectionConfig,
-  ConnectionConfig,
-  ConnectionTypeEnum,
-  CorrelationIdentifierEnum,
-  IConnection,
-  IContact,
-  ICorrelationIdentifier,
-  IDidAuthConfig,
-  IIdentity,
-  IMetadataItem,
-  IOpenIdConfig,
-} from '../types'
-import { ContactEntity, contactEntityFrom } from '../entities/contact/ContactEntity'
-import { IdentityEntity, identityEntityFrom } from '../entities/contact/IdentityEntity'
+import { PartyEntity } from '../entities/contact/PartyEntity'
+import { IdentityEntity } from '../entities/contact/IdentityEntity'
 import { IdentityMetadataItemEntity } from '../entities/contact/IdentityMetadataItemEntity'
 import { CorrelationIdentifierEntity } from '../entities/contact/CorrelationIdentifierEntity'
 import { ConnectionEntity } from '../entities/contact/ConnectionEntity'
 import { BaseConfigEntity } from '../entities/contact/BaseConfigEntity'
-import { OpenIdConfigEntity } from '../entities/contact/OpenIdConfigEntity'
-import { DidAuthConfigEntity } from '../entities/contact/DidAuthConfigEntity'
-import { DataSource, In } from 'typeorm'
+import { PartyRelationshipEntity } from '../entities/contact/PartyRelationshipEntity'
+import { PartyTypeEntity } from '../entities/contact/PartyTypeEntity'
+import {
+  identityEntityFrom,
+  identityFrom,
+  isDidAuthConfig,
+  isNaturalPerson,
+  isOpenIdConfig,
+  isOrganization,
+  partyEntityFrom,
+  partyFrom,
+  partyRelationshipEntityFrom,
+  partyRelationshipFrom,
+  partyTypeEntityFrom,
+  partyTypeFrom,
+} from '../utils/contact/MappingUtils'
+import {
+  AddIdentityArgs,
+  GetIdentityArgs,
+  GetIdentitiesArgs,
+  GetPartyArgs,
+  RemoveIdentityArgs,
+  UpdateIdentityArgs,
+  GetPartiesArgs,
+  AddPartyArgs,
+  UpdatePartyArgs,
+  RemovePartyArgs,
+  NonPersistedConnectionConfig,
+  ConnectionTypeEnum,
+  CorrelationIdentifierEnum,
+  Party,
+  Identity,
+  RemoveRelationshipArgs,
+  PartyRelationship,
+  AddRelationshipArgs,
+  GetRelationshipArgs,
+  AddPartyTypeArgs,
+  PartyType,
+  GetPartyTypeArgs,
+  GetPartyTypesArgs,
+  UpdatePartyTypeArgs,
+  RemovePartyTypeArgs,
+  GetRelationshipsArgs,
+  UpdateRelationshipArgs,
+  PartyTypeEnum,
+  NonPersistedContact,
+} from '../types'
 
-const debug = Debug('sphereon:ssi-sdk:contact-store')
+const debug: Debug.Debugger = Debug('sphereon:ssi-sdk:contact-store')
 
 export class ContactStore extends AbstractContactStore {
   private readonly dbConnection: OrPromise<DataSource>
@@ -44,41 +66,40 @@ export class ContactStore extends AbstractContactStore {
     this.dbConnection = dbConnection
   }
 
-  getContact = async ({ contactId }: IGetContactArgs): Promise<IContact> => {
-    const result = await (await this.dbConnection).getRepository(ContactEntity).findOne({
-      where: { id: contactId },
+  getParty = async ({ partyId }: GetPartyArgs): Promise<Party> => {
+    const result: PartyEntity | null = await (await this.dbConnection).getRepository(PartyEntity).findOne({
+      where: { id: partyId },
     })
 
     if (!result) {
-      return Promise.reject(Error(`No contact found for id: ${contactId}`))
+      return Promise.reject(Error(`No party found for id: ${partyId}`))
     }
 
-    return this.contactFrom(result)
+    return partyFrom(result)
   }
 
-  getContacts = async (args?: IGetContactsArgs): Promise<Array<IContact>> => {
-    const initialResult = await (await this.dbConnection).getRepository(ContactEntity).find({
+  getParties = async (args?: GetPartiesArgs): Promise<Array<Party>> => {
+    const partyRepository: Repository<PartyEntity> = (await this.dbConnection).getRepository(PartyEntity)
+    const initialResult: Array<PartyEntity> = await partyRepository.find({
       ...(args?.filter && { where: args?.filter }),
     })
 
-    const result = await (await this.dbConnection).getRepository(ContactEntity).find({
+    const result: Array<PartyEntity> = await partyRepository.find({
       where: {
-        id: In(initialResult.map((contact: ContactEntity) => contact.id)),
+        id: In(initialResult.map((party: PartyEntity) => party.id)),
       },
     })
 
-    return result.map((contact: ContactEntity) => this.contactFrom(contact))
+    return result.map((party: PartyEntity) => partyFrom(party))
   }
 
-  addContact = async (args: IAddContactArgs): Promise<IContact> => {
-    const { name, alias, uri, identities } = args
+  addParty = async (args: AddPartyArgs): Promise<Party> => {
+    const { identities, contact, partyType } = args
 
-    const result = await (await this.dbConnection).getRepository(ContactEntity).findOne({
-      where: [{ name }, { alias }],
-    })
+    const partyRepository: Repository<PartyEntity> = (await this.dbConnection).getRepository(PartyEntity)
 
-    if (result) {
-      return Promise.reject(Error(`Duplicate names or aliases are not allowed. Name: ${name}, Alias: ${alias}`))
+    if (!this.hasCorrectPartyType(partyType.type, contact)) {
+      return Promise.reject(Error(`Party type ${partyType.type}, does not match for provided contact`))
     }
 
     for (const identity of identities ?? []) {
@@ -87,103 +108,64 @@ export class ContactStore extends AbstractContactStore {
           return Promise.reject(Error(`Identity with correlation type ${CorrelationIdentifierEnum.URL} should contain a connection`))
         }
 
-        if (!this.hasCorrectConfig(identity.connection.type, identity.connection.config)) {
+        if (!this.hasCorrectConnectionConfig(identity.connection.type, identity.connection.config)) {
           return Promise.reject(Error(`Connection type ${identity.connection.type}, does not match for provided config`))
         }
       }
     }
 
-    const contactEntity = contactEntityFrom({ name, alias, uri, identities })
-    debug('Adding contact', name)
-    const createdResult = await (await this.dbConnection).getRepository(ContactEntity).save(contactEntity)
+    const partyEntity: PartyEntity = partyEntityFrom(args)
+    debug('Adding party', args)
+    const createdResult: PartyEntity = await partyRepository.save(partyEntity)
 
-    return this.contactFrom(createdResult)
+    return partyFrom(createdResult)
   }
 
-  updateContact = async ({ contact }: IUpdateContactArgs): Promise<IContact> => {
-    const result = await (await this.dbConnection).getRepository(ContactEntity).findOne({
-      where: { id: contact.id },
+  updateParty = async ({ party }: UpdatePartyArgs): Promise<Party> => {
+    const partyRepository: Repository<PartyEntity> = (await this.dbConnection).getRepository(PartyEntity)
+    const result: PartyEntity | null = await partyRepository.findOne({
+      where: { id: party.id },
     })
 
     if (!result) {
-      return Promise.reject(Error(`No contact found for id: ${contact.id}`))
+      return Promise.reject(Error(`No party found for id: ${party.id}`))
     }
 
-    const updatedContact = {
-      ...contact,
+    const updatedParty = {
+      ...party,
       identities: result.identities,
+      type: result.partyType,
+      relationships: result.relationships,
+      electronicAddresses: result.electronicAddresses,
     }
 
-    debug('Updating contact', contact)
-    const updatedResult = await (await this.dbConnection).getRepository(ContactEntity).save(updatedContact, { transaction: true })
+    debug('Updating party', party)
+    const updatedResult: PartyEntity = await partyRepository.save(updatedParty, { transaction: true })
 
-    return this.contactFrom(updatedResult)
+    return partyFrom(updatedResult)
   }
 
-  removeContact = async ({ contactId }: IRemoveContactArgs): Promise<void> => {
-    debug('Removing contact', contactId)
-    ;(await this.dbConnection)
-      .getRepository(ContactEntity)
-      .findOneById(contactId)
-      .then(async (contact: ContactEntity | null) => {
-        if (!contact) {
-          await Promise.reject(Error(`Unable to find the contact with id to remove: ${contactId}`))
+  removeParty = async ({ partyId }: RemovePartyArgs): Promise<void> => {
+    const partyRepository: Repository<PartyEntity> = (await this.dbConnection).getRepository(PartyEntity)
+    debug('Removing party', partyId)
+    partyRepository
+      .findOneById(partyId)
+      .then(async (party: PartyEntity | null): Promise<void> => {
+        if (!party) {
+          await Promise.reject(Error(`Unable to find the party with id to remove: ${partyId}`))
         } else {
-          await this.deleteIdentities(contact.identities)
+          await this.deleteIdentities(party.identities)
 
-          await (
-            await this.dbConnection
-          )
-            .getRepository(ContactEntity)
-            .delete({ id: contactId })
-            .catch((error) => Promise.reject(Error(`Unable to remove contact with id: ${contactId}. ${error}`)))
+          await partyRepository
+            .delete({ id: partyId })
+            .catch((error) => Promise.reject(Error(`Unable to remove party with id: ${partyId}. ${error}`)))
         }
       })
-      .catch((error) => Promise.reject(Error(`Unable to remove contact with id: ${contactId}. ${error}`)))
+      .catch((error) => Promise.reject(Error(`Unable to remove party with id: ${partyId}. ${error}`)))
   }
 
-  private async deleteIdentities(identities: Array<IdentityEntity>): Promise<void> {
-    debug('Removing identities', identities)
-
-    identities.map(async (identity: IdentityEntity) => {
-      await (
-        await this.dbConnection
-      )
-        .getRepository(CorrelationIdentifierEntity)
-        .delete(identity.identifier.id)
-        .catch((error) => Promise.reject(Error(`Unable to remove identity.identifier with id: ${identity.identifier.id}. ${error}`)))
-
-      if (identity.connection) {
-        await (await this.dbConnection).getRepository(BaseConfigEntity).delete(identity.connection.config.id)
-
-        await (
-          await this.dbConnection
-        )
-          .getRepository(ConnectionEntity)
-          .delete(identity.connection.id)
-          .catch((error) => Promise.reject(Error(`Unable to remove identity.connection with id. ${error}`)))
-      }
-
-      if (identity.metadata) {
-        identity.metadata.map(async (metadataItem: IdentityMetadataItemEntity) => {
-          await (
-            await this.dbConnection
-          )
-            .getRepository(IdentityMetadataItemEntity)
-            .delete(metadataItem.id)
-            .catch((error) => Promise.reject(Error(`Unable to remove metadataItem.id with id ${metadataItem.id}. ${error}`)))
-        })
-      }
-
-      ;(await this.dbConnection)
-        .getRepository(IdentityEntity)
-        .delete(identity.id)
-        .catch((error) => Promise.reject(Error(`Unable to remove metadataItem.id with id ${identity.id}. ${error}`)))
-    })
-  }
-
-  getIdentity = async ({ identityId }: IGetIdentityArgs): Promise<IIdentity> => {
-    const result = await (await this.dbConnection).getRepository(IdentityEntity).findOne({
+  getIdentity = async ({ identityId }: GetIdentityArgs): Promise<Identity> => {
+    const result: IdentityEntity | null = await (await this.dbConnection).getRepository(IdentityEntity).findOne({
       where: { id: identityId },
     })
 
@@ -191,30 +173,31 @@ export class ContactStore extends AbstractContactStore {
       return Promise.reject(Error(`No identity found for id: ${identityId}`))
     }
 
-    return this.identityFrom(result)
+    return identityFrom(result)
   }
 
-  getIdentities = async (args?: IGetIdentitiesArgs): Promise<Array<IIdentity>> => {
-    const initialResult = await (await this.dbConnection).getRepository(IdentityEntity).find({
+  getIdentities = async (args?: GetIdentitiesArgs): Promise<Array<Identity>> => {
+    const identityRepository: Repository<IdentityEntity> = (await this.dbConnection).getRepository(IdentityEntity)
+    const initialResult: Array<IdentityEntity> = await identityRepository.find({
       ...(args?.filter && { where: args?.filter }),
     })
 
-    const result = await (await this.dbConnection).getRepository(IdentityEntity).find({
+    const result: Array<IdentityEntity> = await identityRepository.find({
       where: {
         id: In(initialResult.map((identity: IdentityEntity) => identity.id)),
       },
     })
 
-    return result.map((identity: IdentityEntity) => this.identityFrom(identity))
+    return result.map((identity: IdentityEntity) => identityFrom(identity))
   }
 
-  addIdentity = async ({ identity, contactId }: IAddIdentityArgs): Promise<IIdentity> => {
-    const contact = await (await this.dbConnection).getRepository(ContactEntity).findOne({
-      where: { id: contactId },
+  addIdentity = async ({ identity, partyId }: AddIdentityArgs): Promise<Identity> => {
+    const party: PartyEntity | null = await (await this.dbConnection).getRepository(PartyEntity).findOne({
+      where: { id: partyId },
     })
 
-    if (!contact) {
-      return Promise.reject(Error(`No contact found for id: ${contactId}`))
+    if (!party) {
+      return Promise.reject(Error(`No party found for id: ${partyId}`))
     }
 
     if (identity.identifier.type === CorrelationIdentifierEnum.URL) {
@@ -222,23 +205,24 @@ export class ContactStore extends AbstractContactStore {
         return Promise.reject(Error(`Identity with correlation type ${CorrelationIdentifierEnum.URL} should contain a connection`))
       }
 
-      if (!this.hasCorrectConfig(identity.connection.type, identity.connection.config)) {
+      if (!this.hasCorrectConnectionConfig(identity.connection.type, identity.connection.config)) {
         return Promise.reject(Error(`Connection type ${identity.connection.type}, does not match for provided config`))
       }
     }
 
-    const identityEntity = identityEntityFrom(identity)
-    identityEntity.contact = contact
+    const identityEntity: IdentityEntity = identityEntityFrom(identity)
+    identityEntity.party = party
     debug('Adding identity', identity)
-    const result = await (await this.dbConnection).getRepository(IdentityEntity).save(identityEntity, {
+    const result: IdentityEntity = await (await this.dbConnection).getRepository(IdentityEntity).save(identityEntity, {
       transaction: true,
     })
 
-    return this.identityFrom(result)
+    return identityFrom(result)
   }
 
-  updateIdentity = async ({ identity }: IUpdateIdentityArgs): Promise<IIdentity> => {
-    const result = await (await this.dbConnection).getRepository(IdentityEntity).findOne({
+  updateIdentity = async ({ identity }: UpdateIdentityArgs): Promise<Identity> => {
+    const identityRepository: Repository<IdentityEntity> = (await this.dbConnection).getRepository(IdentityEntity)
+    const result: IdentityEntity | null = await identityRepository.findOne({
       where: { id: identity.id },
     })
 
@@ -251,19 +235,19 @@ export class ContactStore extends AbstractContactStore {
         return Promise.reject(Error(`Identity with correlation type ${CorrelationIdentifierEnum.URL} should contain a connection`))
       }
 
-      if (!this.hasCorrectConfig(identity.connection.type, identity.connection.config)) {
+      if (!this.hasCorrectConnectionConfig(identity.connection.type, identity.connection.config)) {
         return Promise.reject(Error(`Connection type ${identity.connection.type}, does not match for provided config`))
       }
     }
 
     debug('Updating identity', identity)
-    const updatedResult = await (await this.dbConnection).getRepository(IdentityEntity).save(identity, { transaction: true })
+    const updatedResult: IdentityEntity = await identityRepository.save(identity, { transaction: true })
 
-    return this.identityFrom(updatedResult)
+    return identityFrom(updatedResult)
   }
 
-  removeIdentity = async ({ identityId }: IRemoveIdentityArgs): Promise<void> => {
-    const identity = await (await this.dbConnection).getRepository(IdentityEntity).findOne({
+  removeIdentity = async ({ identityId }: RemoveIdentityArgs): Promise<void> => {
+    const identity: IdentityEntity | null = await (await this.dbConnection).getRepository(IdentityEntity).findOne({
       where: { id: identityId },
     })
 
@@ -276,96 +260,236 @@ export class ContactStore extends AbstractContactStore {
     await this.deleteIdentities([identity])
   }
 
-  private contactFrom = (contact: ContactEntity): IContact => {
-    return {
-      id: contact.id,
-      name: contact.name,
-      alias: contact.alias,
-      uri: contact.uri,
-      roles: [...new Set(contact.identities?.flatMap((identity) => identity.roles))] ?? [],
-      identities: contact.identities ? contact.identities.map((identity: IdentityEntity) => this.identityFrom(identity)) : [],
-      createdAt: contact.createdAt,
-      lastUpdatedAt: contact.lastUpdatedAt,
+  addRelationship = async ({ leftId, rightId }: AddRelationshipArgs): Promise<PartyRelationship> => {
+    return this.assertRelationshipSides(leftId, rightId).then(async (): Promise<PartyRelationship> => {
+      const relationship: PartyRelationshipEntity = partyRelationshipEntityFrom({
+        leftId,
+        rightId,
+      })
+      debug('Adding party relationship', relationship)
+
+      const createdResult: PartyRelationshipEntity = await (await this.dbConnection).getRepository(PartyRelationshipEntity).save(relationship)
+
+      return partyRelationshipFrom(createdResult)
+    })
+  }
+
+  getRelationship = async ({ relationshipId }: GetRelationshipArgs): Promise<PartyRelationship> => {
+    const result: PartyRelationshipEntity | null = await (await this.dbConnection).getRepository(PartyRelationshipEntity).findOne({
+      where: { id: relationshipId },
+    })
+
+    if (!result) {
+      return Promise.reject(Error(`No relationship found for id: ${relationshipId}`))
     }
+
+    return partyRelationshipFrom(result)
   }
 
-  private identityFrom = (identity: IdentityEntity): IIdentity => {
-    return {
-      id: identity.id,
-      alias: identity.alias,
-      roles: identity.roles,
-      identifier: this.correlationIdentifierFrom(identity.identifier),
-      ...(identity.connection && { connection: this.connectionFrom(identity.connection) }),
-      metadata: identity.metadata ? identity.metadata.map((item: IdentityMetadataItemEntity) => this.metadataItemFrom(item)) : [],
-      createdAt: identity.createdAt,
-      lastUpdatedAt: identity.createdAt,
+  getRelationships = async (args?: GetRelationshipsArgs): Promise<Array<PartyRelationship>> => {
+    const partyRelationshipRepository: Repository<PartyRelationshipEntity> = (await this.dbConnection).getRepository(PartyRelationshipEntity)
+    const initialResult: Array<PartyRelationshipEntity> = await partyRelationshipRepository.find({
+      ...(args?.filter && { where: args?.filter }),
+    })
+
+    const result: Array<PartyRelationshipEntity> = await partyRelationshipRepository.find({
+      where: {
+        id: In(initialResult.map((partyRelationship: PartyRelationshipEntity) => partyRelationship.id)),
+      },
+    })
+
+    return result.map((partyRelationship: PartyRelationshipEntity) => partyRelationshipFrom(partyRelationship))
+  }
+
+  updateRelationship = async ({ relationship }: UpdateRelationshipArgs): Promise<PartyRelationship> => {
+    const partyRelationshipRepository: Repository<PartyRelationshipEntity> = (await this.dbConnection).getRepository(PartyRelationshipEntity)
+    const result: PartyRelationshipEntity | null = await partyRelationshipRepository.findOne({
+      where: { id: relationship.id },
+    })
+
+    if (!result) {
+      return Promise.reject(Error(`No party relationship found for id: ${relationship.id}`))
+    }
+
+    return this.assertRelationshipSides(relationship.leftId, relationship.rightId).then(async (): Promise<PartyRelationship> => {
+      debug('Updating party relationship', relationship)
+      const updatedResult: PartyRelationshipEntity = await partyRelationshipRepository.save(relationship, { transaction: true })
+
+      return partyRelationshipFrom(updatedResult)
+    })
+  }
+
+  removeRelationship = async ({ relationshipId }: RemoveRelationshipArgs): Promise<void> => {
+    const partyRelationshipRepository: Repository<PartyRelationshipEntity> = (await this.dbConnection).getRepository(PartyRelationshipEntity)
+    const relationship: PartyRelationshipEntity | null = await partyRelationshipRepository.findOne({
+      where: { id: relationshipId },
+    })
+
+    if (!relationship) {
+      return Promise.reject(Error(`No relationship found for id: ${relationshipId}`))
     }
+
+    debug('Removing relationship', relationshipId)
+
+    await partyRelationshipRepository.delete(relationshipId)
+  }
+
+  addPartyType = async (args: AddPartyTypeArgs): Promise<PartyType> => {
+    const partyEntity: PartyTypeEntity = partyTypeEntityFrom(args)
+    debug('Adding party type', args)
+    const createdResult: PartyTypeEntity = await (await this.dbConnection).getRepository(PartyTypeEntity).save(partyEntity)
+
+    return partyTypeFrom(createdResult)
   }
 
-  private correlationIdentifierFrom = (identifier: CorrelationIdentifierEntity): ICorrelationIdentifier => {
-    return {
-      id: identifier.id,
-      type: identifier.type,
-      correlationId: identifier.correlationId,
+  getPartyType = async ({ partyTypeId }: GetPartyTypeArgs): Promise<PartyType> => {
+    const result: PartyTypeEntity | null = await (await this.dbConnection).getRepository(PartyTypeEntity).findOne({
+      where: { id: partyTypeId },
+    })
+
+    if (!result) {
+      return Promise.reject(Error(`No party type found for id: ${partyTypeId}`))
     }
+
+    return partyTypeFrom(result)
   }
 
-  private metadataItemFrom = (item: IdentityMetadataItemEntity): IMetadataItem => {
-    return {
-      id: item.id,
-      label: item.label,
-      value: item.value,
+  getPartyTypes = async (args?: GetPartyTypesArgs): Promise<Array<PartyType>> => {
+    const partyTypeRepository: Repository<PartyTypeEntity> = (await this.dbConnection).getRepository(PartyTypeEntity)
+    const initialResult: Array<PartyTypeEntity> = await partyTypeRepository.find({
+      ...(args?.filter && { where: args?.filter }),
+    })
+
+    const result: Array<PartyTypeEntity> = await partyTypeRepository.find({
+      where: {
+        id: In(initialResult.map((partyType: PartyTypeEntity) => partyType.id)),
+      },
+    })
+
+    return result.map((partyType: PartyTypeEntity) => partyTypeFrom(partyType))
+  }
+
+  updatePartyType = async ({ partyType }: UpdatePartyTypeArgs): Promise<PartyType> => {
+    const partyTypeRepository: Repository<PartyTypeEntity> = (await this.dbConnection).getRepository(PartyTypeEntity)
+    const result: PartyTypeEntity | null = await partyTypeRepository.findOne({
+      where: { id: partyType.id },
+    })
+
+    if (!result) {
+      return Promise.reject(Error(`No party type found for id: ${partyType.id}`))
     }
+
+    debug('Updating party type', partyType)
+    const updatedResult: PartyTypeEntity = await partyTypeRepository.save(partyType, { transaction: true })
+
+    return partyTypeFrom(updatedResult)
   }
 
-  private connectionFrom = (connection: ConnectionEntity): IConnection => {
-    return {
-      id: connection.id,
-      type: connection.type,
-      config: this.configFrom(connection.type, connection.config),
+  removePartyType = async ({ partyTypeId }: RemovePartyTypeArgs): Promise<void> => {
+    const parties: Array<PartyEntity> = await (await this.dbConnection).getRepository(PartyEntity).find({
+      where: {
+        partyType: {
+          id: partyTypeId,
+        },
+      },
+    })
+
+    if (parties.length > 0) {
+      return Promise.reject(Error(`Unable to remove party type with id: ${partyTypeId}. Party type is in use`))
     }
+
+    const partyTypeRepository: Repository<PartyTypeEntity> = (await this.dbConnection).getRepository(PartyTypeEntity)
+    const partyType: PartyTypeEntity | null = await partyTypeRepository.findOne({
+      where: { id: partyTypeId },
+    })
+
+    if (!partyType) {
+      return Promise.reject(Error(`No party type found for id: ${partyTypeId}`))
+    }
+
+    debug('Removing party type', partyTypeId)
+
+    await partyTypeRepository.delete(partyTypeId)
   }
 
-  private configFrom = (type: ConnectionTypeEnum, config: BaseConfigEntity): ConnectionConfig => {
+  private hasCorrectConnectionConfig(type: ConnectionTypeEnum, config: NonPersistedConnectionConfig): boolean {
     switch (type) {
       case ConnectionTypeEnum.OPENID_CONNECT:
-        return {
-          id: (config as OpenIdConfigEntity).id,
-          clientId: (config as OpenIdConfigEntity).clientId,
-          clientSecret: (config as OpenIdConfigEntity).clientSecret,
-          scopes: (config as OpenIdConfigEntity).scopes,
-          issuer: (config as OpenIdConfigEntity).issuer!, // TODO fixme
-          redirectUrl: (config as OpenIdConfigEntity).redirectUrl,
-          dangerouslyAllowInsecureHttpRequests: (config as OpenIdConfigEntity).dangerouslyAllowInsecureHttpRequests,
-          clientAuthMethod: (config as OpenIdConfigEntity).clientAuthMethod,
-        }
+        return isOpenIdConfig(config)
       case ConnectionTypeEnum.SIOPv2:
-        return {
-          id: (config as DidAuthConfigEntity).id,
-          identifier: { did: (config as DidAuthConfigEntity).identifier, provider: '', keys: [], services: [] },
-          stateId: '',
-          redirectUrl: (config as DidAuthConfigEntity).redirectUrl,
-          sessionId: (config as DidAuthConfigEntity).sessionId,
-        }
+        return isDidAuthConfig(config)
       default:
         throw new Error('Connection type not supported')
     }
   }
 
-  private hasCorrectConfig(type: ConnectionTypeEnum, config: BasicConnectionConfig): boolean {
+  private hasCorrectPartyType(type: PartyTypeEnum, contact: NonPersistedContact): boolean {
     switch (type) {
-      case ConnectionTypeEnum.OPENID_CONNECT:
-        return this.isOpenIdConfig(config)
-      case ConnectionTypeEnum.SIOPv2:
-        return this.isDidAuthConfig(config)
+      case PartyTypeEnum.NATURAL_PERSON:
+        return isNaturalPerson(contact)
+      case PartyTypeEnum.ORGANIZATION:
+        return isOrganization(contact)
       default:
-        throw new Error('Connection type not supported')
+        throw new Error('Party type not supported')
     }
   }
 
-  private isOpenIdConfig = (config: BasicConnectionConfig): config is IOpenIdConfig =>
-    'clientSecret' in config && 'issuer' in config && 'redirectUrl' in config
+  private async deleteIdentities(identities: Array<IdentityEntity>): Promise<void> {
+    debug('Removing identities', identities)
 
-  private isDidAuthConfig = (config: BasicConnectionConfig): config is IDidAuthConfig =>
-    'identifier' in config && 'redirectUrl' in config && 'sessionId' in config
+    identities.map(async (identity: IdentityEntity): Promise<void> => {
+      await (
+        await this.dbConnection
+      )
+        .getRepository(CorrelationIdentifierEntity)
+        .delete(identity.identifier.id)
+        .catch((error) => Promise.reject(Error(`Unable to remove identity.identifier with id: ${identity.identifier.id}. ${error}`)))
+
+      if (identity.connection) {
+        await (await this.dbConnection).getRepository(BaseConfigEntity).delete(identity.connection.config.id)
+
+        await (
+          await this.dbConnection
+        )
+          .getRepository(ConnectionEntity)
+          .delete(identity.connection.id)
+          .catch((error) => Promise.reject(Error(`Unable to remove identity.connection with id. ${error}`)))
+      }
+
+      if (identity.metadata) {
+        identity.metadata.map(async (metadataItem: IdentityMetadataItemEntity): Promise<void> => {
+          await (
+            await this.dbConnection
+          )
+            .getRepository(IdentityMetadataItemEntity)
+            .delete(metadataItem.id)
+            .catch((error) => Promise.reject(Error(`Unable to remove metadataItem.id with id ${metadataItem.id}. ${error}`)))
+        })
+      }
+
+      ;(await this.dbConnection)
+        .getRepository(IdentityEntity)
+        .delete(identity.id)
+        .catch((error) => Promise.reject(Error(`Unable to remove metadataItem.id with id ${identity.id}. ${error}`)))
+    })
+  }
+
+  private async assertRelationshipSides(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 },
+    })
+
+    if (!leftParty) {
+      return Promise.reject(Error(`No party found for left side of the relationship, party id: ${leftId}`))
+    }
+
+    const rightParty: PartyEntity | null = await partyRepository.findOne({
+      where: { id: rightId },
+    })
+
+    if (!rightParty) {
+      return Promise.reject(Error(`No party found for right side of the relationship, party id: ${rightId}`))
+    }
+  }
 }